1b07e4e315
Testing feature macros is not enough for uclibc. Fixes build of the built-in sqlite3 with uclibc <= 0.9.33.2. Later versions will have posix_fallocate(). Change-Id: I918a52777ac63624635802221effc6b86fa2269c Reviewed-by: Konstantin Ritt <ritt.ks@gmail.com> Reviewed-by: Oswald Buddenhagen <oswald.buddenhagen@digia.com> Reviewed-by: Mark Brand <mabrand@mabrand.nl>
6955 lines
226 KiB
Bash
Executable File
6955 lines
226 KiB
Bash
Executable File
#!/bin/sh
|
|
#############################################################################
|
|
##
|
|
## Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
|
|
## Copyright (C) 2013 Intel Corporation.
|
|
## Contact: http://www.qt-project.org/legal
|
|
##
|
|
## This file is the build configuration utility of the Qt Toolkit.
|
|
##
|
|
## $QT_BEGIN_LICENSE:LGPL$
|
|
## Commercial License Usage
|
|
## Licensees holding valid commercial Qt licenses may use this file in
|
|
## accordance with the commercial license agreement provided with the
|
|
## Software or, alternatively, in accordance with the terms contained in
|
|
## a written agreement between you and Digia. For licensing terms and
|
|
## conditions see http://qt.digia.com/licensing. For further information
|
|
## use the contact form at http://qt.digia.com/contact-us.
|
|
##
|
|
## GNU Lesser General Public License Usage
|
|
## Alternatively, this file may be used under the terms of the GNU Lesser
|
|
## General Public License version 2.1 as published by the Free Software
|
|
## Foundation and appearing in the file LICENSE.LGPL included in the
|
|
## packaging of this file. Please review the following information to
|
|
## ensure the GNU Lesser General Public License version 2.1 requirements
|
|
## will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
|
|
##
|
|
## In addition, as a special exception, Digia gives you certain additional
|
|
## rights. These rights are described in the Digia Qt LGPL Exception
|
|
## version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
|
|
##
|
|
## GNU General Public License Usage
|
|
## Alternatively, this file may be used under the terms of the GNU
|
|
## General Public License version 3.0 as published by the Free Software
|
|
## Foundation and appearing in the file LICENSE.GPL included in the
|
|
## packaging of this file. Please review the following information to
|
|
## ensure the GNU General Public License version 3.0 requirements will be
|
|
## met: http://www.gnu.org/copyleft/gpl.html.
|
|
##
|
|
##
|
|
## $QT_END_LICENSE$
|
|
##
|
|
#############################################################################
|
|
|
|
#-------------------------------------------------------------------------------
|
|
# script initialization
|
|
#-------------------------------------------------------------------------------
|
|
|
|
# the name of this script
|
|
relconf=`basename $0`
|
|
# the directory of this script is the "source tree"
|
|
relpath=`dirname $0`
|
|
relpath=`(cd "$relpath"; /bin/pwd)`
|
|
# the current directory is the "build tree" or "object tree"
|
|
outpath=`/bin/pwd`
|
|
|
|
# where to find which..
|
|
unixtests="$relpath/config.tests/unix"
|
|
mactests="$relpath/config.tests/mac"
|
|
WHICH="$unixtests/which.test"
|
|
|
|
PERL=`$WHICH perl 2>/dev/null`
|
|
|
|
# find out which awk we want to use, prefer gawk, then nawk, then regular awk
|
|
AWK=
|
|
for e in gawk nawk awk; do
|
|
if "$WHICH" $e >/dev/null 2>&1 && ( $e -f /dev/null /dev/null ) >/dev/null 2>&1; then
|
|
AWK=$e
|
|
break
|
|
fi
|
|
done
|
|
|
|
# find a make command
|
|
if [ -z "$MAKE" ]; then
|
|
MAKE=
|
|
for mk in gmake make; do
|
|
if "$WHICH" $mk >/dev/null 2>&1; then
|
|
MAKE=`"$WHICH" $mk`
|
|
break
|
|
fi
|
|
done
|
|
if [ -z "$MAKE" ]; then
|
|
echo >&2 "You don't seem to have 'make' or 'gmake' in your PATH."
|
|
echo >&2 "Cannot proceed."
|
|
exit 1
|
|
fi
|
|
# export MAKE, we need it later in the config.tests
|
|
export MAKE
|
|
fi
|
|
|
|
# do this early so we don't store it in config.status
|
|
CFG_TOPLEVEL=
|
|
if [ x"$1" = x"-top-level" ]; then
|
|
CFG_TOPLEVEL=yes
|
|
shift
|
|
fi
|
|
|
|
# later cache the command line in config.status
|
|
OPT_CMDLINE=`echo $@ | sed "s,-v ,,g; s,-v$,,g"`
|
|
|
|
# initialize global variables
|
|
QMAKE_SWITCHES=
|
|
QMAKE_VARS=
|
|
QMAKE_CONFIG=
|
|
QTCONFIG_CONFIG=
|
|
QT_CONFIG=
|
|
SUPPORTED=
|
|
QMAKE_VARS_FILE=.qmake.vars
|
|
DEVICE_VARS_FILE=.device.vars
|
|
|
|
:> "$QMAKE_VARS_FILE"
|
|
:> "$DEVICE_VARS_FILE"
|
|
|
|
#-------------------------------------------------------------------------------
|
|
# utility functions
|
|
#-------------------------------------------------------------------------------
|
|
|
|
shellEscape()
|
|
{
|
|
echo "$@" | sed 's/ /\ /g'
|
|
}
|
|
|
|
shellQuoteLines()
|
|
{
|
|
# The call of the outer echo makes the shell word-split the output of
|
|
# the nested pipe, thus effectively converting newlines to spaces.
|
|
echo `echo "$1" | sed 's,^[^ ]* .*$,"&",'`
|
|
}
|
|
|
|
# Adds a new qmake variable to the cache
|
|
# Usage: QMakeVar mode varname contents
|
|
# where mode is one of: set, add, del
|
|
QMakeVar()
|
|
{
|
|
case "$1" in
|
|
set)
|
|
eq="="
|
|
;;
|
|
add)
|
|
eq="+="
|
|
;;
|
|
del)
|
|
eq="-="
|
|
;;
|
|
*)
|
|
echo >&2 "BUG: wrong command to QMakeVar: $1"
|
|
;;
|
|
esac
|
|
|
|
echo "$2" "$eq" "$3" >> "$QMAKE_VARS_FILE"
|
|
}
|
|
|
|
shellArgumentListToQMakeListHelper()
|
|
{
|
|
local retval
|
|
for arg in "$@"; do retval="$retval \"$arg\""; done
|
|
echo "$retval"
|
|
}
|
|
|
|
# Convert a string usable on a shell command line into word-by-word quoted
|
|
# qmake list.
|
|
shellArgumentListToQMakeList()
|
|
{
|
|
# eval is needed for the shell to interpret the backslash escape sequences
|
|
eval shellArgumentListToQMakeListHelper "$@"
|
|
}
|
|
|
|
# Helper function for getQMakeConf. It parses include statements in
|
|
# qmake.conf and prints out the expanded file
|
|
expandQMakeConf()
|
|
{
|
|
while read line; do case "$line" in
|
|
include*)
|
|
inc_file=`echo "$line" | sed -n -e "/^include.*(.*)/s/include.*(\(.*\)).*$/\1/p"`
|
|
current_dir=`dirname "$1"`
|
|
conf_file="$current_dir/$inc_file"
|
|
if [ ! -f "$conf_file" ]; then
|
|
echo "WARNING: Unable to find file $conf_file" >&2
|
|
continue
|
|
fi
|
|
expandQMakeConf "$conf_file"
|
|
;;
|
|
*load\(device_config\)*)
|
|
conf_file="$DEVICE_VARS_FILE"
|
|
if [ ! -f "$conf_file" ]; then
|
|
echo "WARNING: Unable to find file $conf_file" >&2
|
|
continue
|
|
fi
|
|
expandQMakeConf "$conf_file"
|
|
;;
|
|
*)
|
|
echo "$line"
|
|
;;
|
|
esac; done < "$1"
|
|
}
|
|
|
|
extractQMakeVariables()
|
|
{
|
|
$AWK '
|
|
BEGIN {
|
|
values["LITERAL_WHITESPACE"] = " "
|
|
values["LITERAL_DOLLAR"] = "$"
|
|
}
|
|
/^!?host_build:/ {
|
|
scopeStart = index($0, ":") + 1
|
|
condition = substr($0, 0, scopeStart - 2)
|
|
if (condition != "'"$1"'") { next }
|
|
$0 = substr($0, scopeStart)
|
|
}
|
|
/^[_A-Z0-9.]+[ \t]*\+?=/ {
|
|
valStart = index($0, "=") + 1
|
|
|
|
append = 0
|
|
if (substr($0, valStart - 2, 1) == "+") {
|
|
append = 1
|
|
}
|
|
|
|
variable = substr($0, 0, valStart - 2 - append)
|
|
value = substr($0, valStart)
|
|
gsub("[ \t]+", "", variable)
|
|
gsub("^[ \t]+", "", value)
|
|
gsub("[ \t]+$", "", value)
|
|
|
|
ovalue = ""
|
|
while (match(value, /\$\$(\{[_A-Z0-9.]+\}|[_A-Z0-9.]+)/)) {
|
|
ovalue = ovalue substr(value, 1, RSTART - 1)
|
|
var = substr(value, RSTART + 2, RLENGTH - 2)
|
|
value = substr(value, RSTART + RLENGTH)
|
|
if (var ~ /^\{/) {
|
|
var = substr(var, 2, length(var) - 2)
|
|
}
|
|
ovalue = ovalue values[var]
|
|
}
|
|
value = ovalue value
|
|
|
|
ovalue = ""
|
|
while (match(value, /\$\$system\(("[^"]*"|[^)]*)\)/)) {
|
|
ovalue = ovalue substr(value, 1, RSTART - 1)
|
|
cmd = substr(value, RSTART + 9, RLENGTH - 10)
|
|
gsub(/^"|"$/, "", cmd)
|
|
value = substr(value, RSTART + RLENGTH)
|
|
while ((cmd | getline line) > 0) {
|
|
ovalue = ovalue line
|
|
}
|
|
close(cmd)
|
|
}
|
|
value = ovalue value
|
|
|
|
combinedValue = values[variable]
|
|
if (append == 1 && length(combinedValue) > 0) {
|
|
combinedValue = combinedValue " " value
|
|
} else {
|
|
combinedValue = value
|
|
}
|
|
values[variable] = combinedValue
|
|
}
|
|
END {
|
|
for (var in values) {
|
|
print var "=" values[var]
|
|
}
|
|
}
|
|
'
|
|
}
|
|
|
|
getSingleQMakeVariable()
|
|
{
|
|
echo "$2" | $AWK "/^($1)=/ { print substr(\$0, index(\$0, \"=\") + 1) }"
|
|
}
|
|
|
|
macSDKify()
|
|
{
|
|
# Normally we take care of sysrootifying in sdk.prf, but configure extracts some
|
|
# values before qmake is even built, so we have to duplicate the logic here.
|
|
|
|
sdk=$(getSingleQMakeVariable "QMAKE_MAC_SDK" "$1")
|
|
if [ -z "$sdk" ]; then echo "QMAKE_MAC_SDK must be set when building on Mac" >&2; exit 1; fi
|
|
sysroot=$(/usr/bin/xcodebuild -sdk $sdk -version Path 2>/dev/null)
|
|
if [ -z "$sysroot" ]; then echo "Failed to resolve SDK path for '$sdk'" >&2; exit 1; fi
|
|
|
|
case "$sdk" in
|
|
macosx*)
|
|
version_min_flag="-mmacosx-version-min=$(getSingleQMakeVariable QMAKE_MACOSX_DEPLOYMENT_TARGET "$1")"
|
|
;;
|
|
iphoneos*)
|
|
version_min_flag="-miphoneos-version-min=$(getSingleQMakeVariable QMAKE_IOS_DEPLOYMENT_TARGET "$1")"
|
|
;;
|
|
iphonesimulator*)
|
|
version_min_flag="-mios-simulator-version-min=$(getSingleQMakeVariable QMAKE_IOS_DEPLOYMENT_TARGET "$1")"
|
|
;;
|
|
*)
|
|
;;
|
|
esac
|
|
|
|
echo "$1" | while read line; do
|
|
case "$line" in
|
|
QMAKE_CC=*|QMAKE_CXX=*|QMAKE_FIX_RPATH=*|QMAKE_AR=*|QMAKE_RANLIB=*|QMAKE_LINK=*|QMAKE_LINK_SHLIB=*)
|
|
# Prefix tool with toolchain path
|
|
var=$(echo "$line" | cut -d '=' -f 1)
|
|
val=$(echo "$line" | cut -d '=' -f 2-)
|
|
sdk_val=$(/usr/bin/xcrun -sdk $sdk -find $(echo $val | cut -d ' ' -f 1))
|
|
val=$(echo $sdk_val $(echo $val | cut -s -d ' ' -f 2-))
|
|
echo "$var=$val"
|
|
;;
|
|
QMAKE_CFLAGS=*|QMAKE_CXXFLAGS=*|QMAKE_OBJECTIVE_CFLAGS=*)
|
|
echo "$line -isysroot $sysroot $version_min_flag"
|
|
;;
|
|
QMAKE_LFLAGS=*)
|
|
echo "$line -Wl,-syslibroot,$sysroot $version_min_flag"
|
|
;;
|
|
*)
|
|
echo "$line"
|
|
;;
|
|
esac
|
|
done
|
|
}
|
|
|
|
# relies on $QMAKESPEC being set correctly. parses include statements in
|
|
# qmake.conf and prints out the expanded file
|
|
getQMakeConf()
|
|
{
|
|
if [ -z "$specvals" ]; then
|
|
specvals=`expandQMakeConf "$QMAKESPEC/qmake.conf" | extractQMakeVariables "host_build"`
|
|
if [ "$BUILD_ON_MAC" = "yes" ]; then specvals=$(macSDKify "$specvals"); fi
|
|
fi
|
|
getSingleQMakeVariable "$1" "$specvals"
|
|
}
|
|
|
|
getXQMakeConf()
|
|
{
|
|
if [ -z "$xspecvals" ]; then
|
|
xspecvals=`expandQMakeConf "$XQMAKESPEC/qmake.conf" | extractQMakeVariables "!host_build"`
|
|
if [ "$XPLATFORM_MAC" = "yes" ]; then xspecvals=$(macSDKify "$xspecvals"); fi
|
|
fi
|
|
getSingleQMakeVariable "$1" "$xspecvals"
|
|
}
|
|
|
|
compilerSupportsFlag()
|
|
{
|
|
cat >conftest.cpp <<EOF
|
|
int main() { return 0; }
|
|
EOF
|
|
"$@" -o conftest-out.o conftest.cpp
|
|
ret=$?
|
|
rm -f conftest.cpp conftest-out.o
|
|
return $ret
|
|
}
|
|
|
|
linkerSupportsFlag()
|
|
{
|
|
compiler=$1
|
|
shift
|
|
lflags=-Wl
|
|
for flag
|
|
do
|
|
safe_flag=`shellEscape "$flag"`
|
|
lflags=$lflags,$safe_flag
|
|
done
|
|
compilerSupportsFlag $compiler $lflags >/dev/null 2>&1
|
|
}
|
|
|
|
# $1: newline-separated list of default paths
|
|
# stdin: input path
|
|
# stdout: input path or nothing
|
|
filterDefaultPaths()
|
|
{
|
|
local path
|
|
path=`cat`
|
|
echo "$1" | grep "^$path\$" > /dev/null || echo "$path"
|
|
}
|
|
|
|
filterIncludePath()
|
|
{
|
|
filterDefaultPaths "$DEFAULT_INCDIRS"
|
|
}
|
|
|
|
filterLibraryPath()
|
|
{
|
|
filterDefaultPaths "$DEFAULT_LIBDIRS"
|
|
}
|
|
|
|
filterPathOptionsHelper()
|
|
{
|
|
local flag defpaths sep p path
|
|
flag=$1; shift
|
|
defpaths=$1; shift
|
|
sep=
|
|
for p in "$@"; do
|
|
path=${p#$flag}
|
|
if [ "x$path" != "x$p" ]; then
|
|
path=`echo "$path" | filterDefaultPaths "$defpaths"`
|
|
test -z "$path" && continue
|
|
fi
|
|
# Re-quote for shell & qmake
|
|
p=`echo "$p" | sed 's,[^ ]* .*,"&",g'`
|
|
printf "%s%s" "$sep" "$p"
|
|
sep=" "
|
|
done
|
|
echo
|
|
}
|
|
|
|
# $1: flag
|
|
# $2: newline-separated list of default paths
|
|
# stdin: list of command line options
|
|
# sdout: stdin without the options naming default paths
|
|
filterPathOptions()
|
|
{
|
|
# The eval does escape interpretation for us
|
|
eval filterPathOptionsHelper $1 "\"$2\"" "`cat`"
|
|
}
|
|
|
|
filterIncludeOptions()
|
|
{
|
|
filterPathOptions -I "$DEFAULT_INCDIRS"
|
|
}
|
|
|
|
filterLibraryOptions()
|
|
{
|
|
filterPathOptions -L "$DEFAULT_LIBDIRS"
|
|
}
|
|
|
|
substPrefix()
|
|
{
|
|
base=${1#$QT_SYSROOT_PREFIX}
|
|
if [ x"$base" != x"$1" ]; then
|
|
echo "$QT_EXT_PREFIX$base"
|
|
else
|
|
echo "$1"
|
|
fi
|
|
}
|
|
|
|
#-------------------------------------------------------------------------------
|
|
# device options
|
|
#-------------------------------------------------------------------------------
|
|
DeviceVar()
|
|
{
|
|
case "$1" in
|
|
set)
|
|
eq="="
|
|
;;
|
|
*)
|
|
echo >&2 "BUG: wrong command to QMakeVar: $1"
|
|
;;
|
|
esac
|
|
|
|
echo "$2" "$eq" "$3" >> "$DEVICE_VARS_FILE"
|
|
}
|
|
|
|
resolveDeviceMkspec()
|
|
{
|
|
result=$(find "$relpath/mkspecs/devices/" -type d -name "*$1*" | sed "s,^$relpath/mkspecs/,,")
|
|
match_count=$(echo "$result" | wc -w)
|
|
if [ "$match_count" -gt 1 ]; then
|
|
echo >&2 "Error: Multiple matches for device '$1'. Candidates are:"
|
|
tabbed_result=$(echo "$result" | sed "s,^, ,")
|
|
echo >&2 "$tabbed_result"
|
|
echo "undefined"
|
|
elif [ "$match_count" -eq 0 ]; then
|
|
echo >&2 "Error: No device matching '$1'"
|
|
echo "undefined"
|
|
else
|
|
echo "$result"
|
|
fi
|
|
}
|
|
|
|
#-------------------------------------------------------------------------------
|
|
# operating system detection
|
|
#-------------------------------------------------------------------------------
|
|
|
|
# need that throughout the script
|
|
UNAME_MACHINE=`(uname -m) 2>/dev/null` || UNAME_MACHINE=unknown
|
|
UNAME_RELEASE=`(uname -r) 2>/dev/null` || UNAME_RELEASE=unknown
|
|
UNAME_SYSTEM=`(uname -s) 2>/dev/null` || UNAME_SYSTEM=unknown
|
|
UNAME_VERSION=`(uname -v) 2>/dev/null` || UNAME_VERSION=unknown
|
|
|
|
# detect the "echo without newline" style. usage: echo $ECHO_N "<string>$ECHO_C"
|
|
if echo '\c' | grep '\c' >/dev/null; then
|
|
ECHO_N=-n
|
|
else
|
|
ECHO_C='\c'
|
|
fi
|
|
|
|
#-------------------------------------------------------------------------------
|
|
# window system detection
|
|
#-------------------------------------------------------------------------------
|
|
|
|
BUILD_ON_MAC=no
|
|
if [ -d /System/Library/Frameworks/Carbon.framework ]; then
|
|
BUILD_ON_MAC=yes
|
|
fi
|
|
BUILD_ON_MSYS=no
|
|
HOST_DIRLIST_SEP=":"
|
|
DEV_NULL=/dev/null
|
|
if [ "$OSTYPE" = "msys" ]; then
|
|
HOST_DIRLIST_SEP=";"
|
|
BUILD_ON_MSYS=yes
|
|
DEV_NULL=/tmp/empty-file
|
|
echo "" > $DEV_NULL
|
|
relpath=`(cd "$relpath"; pwd -W)`
|
|
outpath=`pwd -W`
|
|
fi
|
|
|
|
#-------------------------------------------------------------------------------
|
|
# Verify Xcode installation on Mac OS
|
|
#-------------------------------------------------------------------------------
|
|
|
|
if [ "$BUILD_ON_MAC" = "yes" ]; then
|
|
if ! /usr/bin/xcode-select --print-path >/dev/null 2>&1; then
|
|
echo >&2
|
|
echo " No Xcode is selected. Use xcode-select -switch to choose an Xcode" >&2
|
|
echo " version. See the xcode-select man page for more information." >&2
|
|
echo >&2
|
|
exit 2
|
|
fi
|
|
|
|
if ! /usr/bin/xcrun -find xcrun >/dev/null 2>&1; then
|
|
echo >&2
|
|
echo " Xcode not set up properly. You may need to confirm the license" >&2
|
|
echo " agreement by running /usr/bin/xcodebuild without arguments." >&2
|
|
echo >&2
|
|
exit 2
|
|
fi
|
|
fi
|
|
|
|
#-----------------------------------------------------------------------------
|
|
# Qt version detection
|
|
#-----------------------------------------------------------------------------
|
|
QT_VERSION=`grep '^# *define *QT_VERSION_STR' "$relpath"/src/corelib/global/qglobal.h`
|
|
QT_MAJOR_VERSION=
|
|
QT_MINOR_VERSION=0
|
|
QT_PATCH_VERSION=0
|
|
if [ -n "$QT_VERSION" ]; then
|
|
QT_VERSION=`echo $QT_VERSION | sed 's,^# *define *QT_VERSION_STR *"*\([^ ]*\)"$,\1,'`
|
|
MAJOR=`echo $QT_VERSION | sed 's,^\([0-9]*\)\.\([0-9]*\)\.\([0-9]*\).*,\1,'`
|
|
if [ -n "$MAJOR" ]; then
|
|
MINOR=`echo $QT_VERSION | sed 's,^\([0-9]*\)\.\([0-9]*\)\.\([0-9]*\).*,\2,'`
|
|
PATCH=`echo $QT_VERSION | sed 's,^\([0-9]*\)\.\([0-9]*\)\.\([0-9]*\).*,\3,'`
|
|
QT_MAJOR_VERSION="$MAJOR"
|
|
[ -z "$MINOR" ] || QT_MINOR_VERSION="$MINOR"
|
|
[ -z "$PATCH" ] || QT_PATCH_VERSION="$PATCH"
|
|
fi
|
|
fi
|
|
if [ -z "$QT_MAJOR_VERSION" ]; then
|
|
echo "Cannot process version from qglobal.h: $QT_VERSION"
|
|
echo "Cannot proceed."
|
|
exit 1
|
|
fi
|
|
|
|
#-------------------------------------------------------------------------------
|
|
# initalize variables
|
|
#-------------------------------------------------------------------------------
|
|
|
|
SYSTEM_VARIABLES="RANLIB STRIP OBJDUMP LD CC CXX CFLAGS CXXFLAGS LDFLAGS"
|
|
for varname in $SYSTEM_VARIABLES; do
|
|
qmakevarname="${varname}"
|
|
# use LDFLAGS for autoconf compat, but qmake uses QMAKE_LFLAGS
|
|
if [ "${varname}" = "LDFLAGS" ]; then
|
|
qmakevarname="LFLAGS"
|
|
elif [ "${varname}" = "LD" ]; then
|
|
qmakevarname="LINK"
|
|
fi
|
|
cmd=`echo \
|
|
'if [ -n "\$'${varname}'" ]; then
|
|
QMakeVar set QMAKE_'${qmakevarname}' "\$'${varname}'"
|
|
fi'`
|
|
eval "$cmd"
|
|
done
|
|
# Use CC/CXX to run config.tests
|
|
mkdir -p "$outpath/config.tests"
|
|
rm -f "$outpath/config.tests/.qmake.cache"
|
|
cp "$QMAKE_VARS_FILE" "$outpath/config.tests/.qmake.cache"
|
|
|
|
QMakeVar add styles "mac fusion windows"
|
|
|
|
# QTDIR may be set and point to an old or system-wide Qt installation
|
|
unset QTDIR
|
|
|
|
# the minimum version of libdbus-1 that we require:
|
|
MIN_DBUS_1_VERSION=1.2
|
|
|
|
# initalize internal variables
|
|
CFG_CONFIGURE_EXIT_ON_ERROR=yes
|
|
CFG_PROFILE=no
|
|
CFG_STRIP=yes
|
|
CFG_GUI=auto # (yes|no|auto)
|
|
CFG_WIDGETS=yes
|
|
CFG_QCONFIG=full
|
|
CFG_DEBUG=auto
|
|
CFG_MYSQL_CONFIG=
|
|
CFG_DEBUG_RELEASE=no
|
|
CFG_FORCEDEBUGINFO=no
|
|
CFG_SHARED=yes
|
|
CFG_SM=auto
|
|
CFG_XSHAPE=auto
|
|
CFG_XSYNC=auto
|
|
CFG_XVIDEO=auto
|
|
CFG_XINERAMA=runtime
|
|
CFG_XFIXES=runtime
|
|
CFG_ZLIB=auto
|
|
CFG_SQLITE=qt
|
|
CFG_GIF=auto
|
|
CFG_PNG=yes
|
|
CFG_LIBPNG=auto
|
|
CFG_JPEG=auto
|
|
CFG_LIBJPEG=auto
|
|
CFG_XCURSOR=runtime
|
|
CFG_XRANDR=runtime
|
|
CFG_XRENDER=auto
|
|
CFG_MITSHM=auto
|
|
CFG_OPENGL=auto
|
|
CFG_OPENVG=auto
|
|
CFG_OPENVG_LC_INCLUDES=no
|
|
CFG_OPENVG_SHIVA=auto
|
|
CFG_OPENVG_ON_OPENGL=auto
|
|
CFG_EGL=auto
|
|
CFG_GLX=auto
|
|
CFG_SSE=auto
|
|
CFG_FONTCONFIG=auto
|
|
CFG_FREETYPE=auto
|
|
CFG_HARFBUZZ=no
|
|
CFG_SQL_AVAILABLE=
|
|
QT_ALL_BUILD_PARTS=" libs tools examples tests "
|
|
QT_DEFAULT_BUILD_PARTS="libs tools examples"
|
|
CFG_BUILD_PARTS=""
|
|
CFG_NOBUILD_PARTS=""
|
|
CFG_SKIP_MODULES=""
|
|
CFG_COMPILE_EXAMPLES=yes
|
|
CFG_RELEASE_QMAKE=no
|
|
CFG_AUDIO_BACKEND=auto
|
|
CFG_QML_DEBUG=yes
|
|
CFG_JAVASCRIPTCORE_JIT=auto
|
|
CFG_PKGCONFIG=auto
|
|
CFG_STACK_PROTECTOR_STRONG=auto
|
|
CFG_SLOG2=auto
|
|
CFG_PPS=auto
|
|
CFG_SYSTEM_PROXIES=no
|
|
|
|
# Target architecture
|
|
CFG_ARCH=
|
|
CFG_CPUFEATURES=
|
|
# Host architecture, same as CFG_ARCH when not cross-compiling
|
|
CFG_HOST_ARCH=
|
|
CFG_HOST_CPUFEATURES=
|
|
# Set when the -arch or -host-arch arguments are used
|
|
OPT_OBSOLETE_HOST_ARG=no
|
|
|
|
CFG_USE_GNUMAKE=no
|
|
CFG_XINPUT2=auto
|
|
CFG_XINPUT=runtime
|
|
CFG_XKB=auto
|
|
CFG_XKBCOMMON=auto
|
|
CFG_XCB=auto
|
|
CFG_XCB_XLIB=auto
|
|
CFG_XCB_GLX=no
|
|
CFG_EGLFS=auto
|
|
CFG_DIRECTFB=auto
|
|
CFG_LINUXFB=auto
|
|
CFG_KMS=auto
|
|
CFG_LIBUDEV=auto
|
|
CFG_OBSOLETE_WAYLAND=no
|
|
CFG_EVDEV=auto
|
|
CFG_TSLIB=no
|
|
CFG_NIS=auto
|
|
CFG_CUPS=auto
|
|
CFG_ICONV=auto
|
|
CFG_DBUS=auto
|
|
CFG_GLIB=auto
|
|
CFG_QGTKSTYLE=auto
|
|
CFG_LARGEFILE=auto
|
|
CFG_OPENSSL=auto
|
|
CFG_PRECOMPILE=auto
|
|
CFG_SEPARATE_DEBUG_INFO=no
|
|
CFG_SEPARATE_DEBUG_INFO_NOCOPY=no
|
|
CFG_REDUCE_EXPORTS=auto
|
|
CFG_SSE2=auto
|
|
CFG_SSE3=auto
|
|
CFG_SSSE3=auto
|
|
CFG_SSE4_1=auto
|
|
CFG_SSE4_2=auto
|
|
CFG_AVX=auto
|
|
CFG_AVX2=auto
|
|
CFG_REDUCE_RELOCATIONS=auto
|
|
CFG_ACCESSIBILITY=auto
|
|
CFG_ACCESSIBILITY_ATSPI_BRIDGE=no # will be enabled depending on dbus and accessibility being enabled
|
|
CFG_IWMMXT=no
|
|
CFG_NEON=auto
|
|
CFG_MIPS_DSP=auto
|
|
CFG_MIPS_DSPR2=auto
|
|
CFG_CLOCK_GETTIME=auto
|
|
CFG_CLOCK_MONOTONIC=auto
|
|
CFG_POSIX_FALLOCATE=auto
|
|
CFG_MREMAP=auto
|
|
CFG_GETADDRINFO=auto
|
|
CFG_IPV6IFNAME=auto
|
|
CFG_GETIFADDRS=auto
|
|
CFG_INOTIFY=auto
|
|
CFG_EVENTFD=auto
|
|
CFG_RPATH=yes
|
|
CFG_FRAMEWORK=auto
|
|
DEFINES=
|
|
D_FLAGS=
|
|
I_FLAGS=
|
|
L_FLAGS=
|
|
RPATH_FLAGS=
|
|
W_FLAGS=
|
|
QCONFIG_FLAGS=
|
|
XPLATFORM= # This seems to be the QMAKESPEC, like "linux-g++"
|
|
XPLATFORM_MAC=no
|
|
XPLATFORM_IOS=no
|
|
XPLATFORM_ANDROID=no
|
|
XPLATFORM_MINGW=no # Whether target platform is MinGW (win32-g++*)
|
|
XPLATFORM_MAEMO=no
|
|
XPLATFORM_QNX=no
|
|
PLATFORM=$QMAKESPEC
|
|
QT_CROSS_COMPILE=no
|
|
OPT_CONFIRM_LICENSE=no
|
|
OPT_SHADOW=maybe
|
|
OPT_VERBOSE=no
|
|
OPT_HELP=
|
|
CFG_SILENT=no
|
|
CFG_ALSA=auto
|
|
CFG_PULSEAUDIO=auto
|
|
CFG_COREWLAN=auto
|
|
CFG_PROCESS=yes
|
|
CFG_ICU=auto
|
|
CFG_FORCE_ASSERTS=no
|
|
CFG_PCRE=auto
|
|
QPA_PLATFORM_GUARD=yes
|
|
CFG_CXX11=auto
|
|
CFG_DIRECTWRITE=no
|
|
CFG_WERROR=auto
|
|
CFG_QREAL=double
|
|
OPT_MAC_SDK=
|
|
COMMERCIAL_USER=ask
|
|
LICENSE_FILE=
|
|
CFG_DEV=no
|
|
|
|
# initalize variables used for installation
|
|
QT_INSTALL_PREFIX=
|
|
QT_INSTALL_DOCS=
|
|
QT_INSTALL_HEADERS=
|
|
QT_INSTALL_LIBS=
|
|
QT_INSTALL_BINS=
|
|
QT_INSTALL_LIBEXECS=
|
|
QT_INSTALL_PLUGINS=
|
|
QT_INSTALL_IMPORTS=
|
|
QT_INSTALL_QML=
|
|
QT_INSTALL_ARCHDATA=
|
|
QT_INSTALL_DATA=
|
|
QT_INSTALL_TRANSLATIONS=
|
|
QT_INSTALL_SETTINGS=
|
|
QT_INSTALL_EXAMPLES=
|
|
QT_INSTALL_TESTS=
|
|
CFG_SYSROOT=
|
|
CFG_GCC_SYSROOT="yes"
|
|
QT_HOST_PREFIX=
|
|
QT_HOST_BINS=
|
|
QT_HOST_LIBS=
|
|
QT_HOST_DATA=
|
|
QT_EXT_PREFIX=
|
|
|
|
#flags for SQL drivers
|
|
QT_CFLAGS_PSQL=
|
|
QT_LFLAGS_PSQL=
|
|
QT_CFLAGS_MYSQL=
|
|
QT_LFLAGS_MYSQL=
|
|
QT_LFLAGS_MYSQL_R=
|
|
QT_CFLAGS_SQLITE=
|
|
QT_LFLAGS_SQLITE=
|
|
QT_LFLAGS_ODBC="-lodbc"
|
|
QT_LFLAGS_TDS=
|
|
|
|
# flags for libdbus-1
|
|
QT_CFLAGS_DBUS=
|
|
QT_LIBS_DBUS=
|
|
|
|
# flags for Glib (X11 only)
|
|
QT_CFLAGS_GLIB=
|
|
QT_LIBS_GLIB=
|
|
|
|
# default qpa platform
|
|
QT_QPA_DEFAULT_PLATFORM=
|
|
|
|
# Android vars
|
|
CFG_DEFAULT_ANDROID_NDK_ROOT=$ANDROID_NDK_ROOT
|
|
CFG_DEFAULT_ANDROID_SDK_ROOT=$ANDROID_SDK_ROOT
|
|
CFG_DEFAULT_ANDROID_PLATFORM=android-9
|
|
CFG_DEFAULT_ANDROID_TARGET_ARCH=armeabi-v7a
|
|
CFG_DEFAULT_ANDROID_NDK_TOOLCHAIN_VERSION=4.8
|
|
CFG_DEFAULT_ANDROID_NDK_HOST=$ANDROID_NDK_HOST
|
|
|
|
#-------------------------------------------------------------------------------
|
|
# check SQL drivers available in this package
|
|
#-------------------------------------------------------------------------------
|
|
|
|
# opensource version removes some drivers, so force them to be off
|
|
CFG_SQL_tds=no
|
|
CFG_SQL_oci=no
|
|
CFG_SQL_db2=no
|
|
|
|
CFG_SQL_AVAILABLE=
|
|
if [ -d "$relpath/src/plugins/sqldrivers" ]; then
|
|
for a in "$relpath/src/plugins/sqldrivers/"*; do
|
|
if [ -d "$a" ]; then
|
|
base_a=`basename "$a"`
|
|
CFG_SQL_AVAILABLE="${CFG_SQL_AVAILABLE} ${base_a}"
|
|
eval "CFG_SQL_${base_a}=auto"
|
|
fi
|
|
done
|
|
fi
|
|
|
|
CFG_IMAGEFORMAT_PLUGIN_AVAILABLE=
|
|
if [ -d "$relpath/src/plugins/imageformats" ]; then
|
|
for a in "$relpath/src/plugins/imageformats/"*; do
|
|
if [ -d "$a" ]; then
|
|
base_a=`basename "$a"`
|
|
CFG_IMAGEFORMAT_PLUGIN_AVAILABLE="${CFG_IMAGEFORMAT_PLUGIN_AVAILABLE} ${base_a}"
|
|
fi
|
|
done
|
|
fi
|
|
|
|
#-------------------------------------------------------------------------------
|
|
# parse command line arguments
|
|
#-------------------------------------------------------------------------------
|
|
|
|
# parse the arguments, setting things to "yes" or "no"
|
|
while [ "$#" -gt 0 ]; do
|
|
CURRENT_OPT="$1"
|
|
UNKNOWN_ARG=no
|
|
case "$1" in
|
|
#Autoconf style options
|
|
--enable-*)
|
|
VAR=`echo $1 | sed "s,^--enable-\(.*\),\1,"`
|
|
VAL=yes
|
|
;;
|
|
--disable-*)
|
|
VAR=`echo $1 | sed "s,^--disable-\(.*\),\1,"`
|
|
VAL=no
|
|
;;
|
|
--*=*)
|
|
VAR=`echo $1 | sed "s,^--\(.*\)=.*,\1,"`
|
|
VAL=`echo $1 | sed "s,^--.*=\(.*\),\1,"`
|
|
;;
|
|
--no-*)
|
|
VAR=`echo $1 | sed "s,^--no-\(.*\),\1,"`
|
|
VAL=no
|
|
;;
|
|
--*)
|
|
VAR=`echo $1 | sed "s,^--\(.*\),\1,"`
|
|
VAL=yes
|
|
;;
|
|
#Qt plugin options
|
|
-no-*-*|-plugin-*-*|-qt-*-*)
|
|
VAR=`echo $1 | sed "s,^-[^-]*-\(.*\),\1,"`
|
|
VAL=`echo $1 | sed "s,^-\([^-]*\).*,\1,"`
|
|
;;
|
|
#Qt style no options
|
|
-no-*)
|
|
VAR=`echo $1 | sed "s,^-no-\(.*\),\1,"`
|
|
VAL=no
|
|
;;
|
|
#Qt style options that pass an argument
|
|
-prefix| \
|
|
-docdir| \
|
|
-headerdir| \
|
|
-plugindir| \
|
|
-importdir| \
|
|
-qmldir| \
|
|
-archdatadir| \
|
|
-datadir| \
|
|
-libdir| \
|
|
-bindir| \
|
|
-libexecdir| \
|
|
-translationdir| \
|
|
-sysconfdir| \
|
|
-examplesdir| \
|
|
-testsdir| \
|
|
-hostdatadir| \
|
|
-hostbindir| \
|
|
-hostlibdir| \
|
|
-extprefix| \
|
|
-sysroot| \
|
|
-depths| \
|
|
-make| \
|
|
-nomake| \
|
|
-skip| \
|
|
-platform| \
|
|
-xplatform| \
|
|
-device| \
|
|
-device-option| \
|
|
-sdk| \
|
|
-arch| \
|
|
-host-arch| \
|
|
-mysql_config| \
|
|
-qpa| \
|
|
-qconfig| \
|
|
-qreal| \
|
|
-android-sdk| \
|
|
-android-ndk| \
|
|
-android-ndk-platform| \
|
|
-android-ndk-host| \
|
|
-android-arch| \
|
|
-android-toolchain-version)
|
|
VAR=`echo $1 | sed "s,^-\(.*\),\1,"`
|
|
shift
|
|
VAL="$1"
|
|
;;
|
|
#Qt style complex options in one command
|
|
-enable-*|-disable-*)
|
|
VAR=`echo $1 | sed "s,^-\([^-]*\)-.*,\1,"`
|
|
VAL=`echo $1 | sed "s,^-[^-]*-\(.*\),\1,"`
|
|
;;
|
|
-system-proxies)
|
|
VAR=system-proxies
|
|
VAL=yes
|
|
;;
|
|
-no-system-proxies)
|
|
VAR=system-proxies
|
|
VAL=no
|
|
;;
|
|
#Qt Builtin/System style options
|
|
-no-*|-system-*|-qt-*)
|
|
VAR=`echo $1 | sed "s,^-[^-]*-\(.*\),\1,"`
|
|
VAL=`echo $1 | sed "s,^-\([^-]*\)-.*,\1,"`
|
|
;;
|
|
#Options that cannot be generalized
|
|
-k|-continue)
|
|
VAR=fatal_error
|
|
VAL=no
|
|
;;
|
|
-opengl)
|
|
VAR=opengl
|
|
# this option may or may not be followed by an argument
|
|
if [ -z "$2" ] || echo "$2" | grep '^-' >/dev/null 2>&1; then
|
|
VAL=yes
|
|
else
|
|
shift;
|
|
VAL=$1
|
|
fi
|
|
;;
|
|
-openvg)
|
|
VAR=openvg
|
|
# this option may or may not be followed by an argument
|
|
if [ -z "$2" ] || echo "$2" | grep '^-' >/dev/null 2>&1; then
|
|
VAL=yes
|
|
else
|
|
shift;
|
|
VAL=$1
|
|
fi
|
|
;;
|
|
-hostprefix)
|
|
VAR=`echo $1 | sed "s,^-\(.*\),\1,"`
|
|
# this option may or may not be followed by an argument
|
|
if [ -z "$2" ] || echo "$2" | grep '^-' >/dev/null 2>&1; then
|
|
VAL=$outpath
|
|
else
|
|
shift;
|
|
VAL=$1
|
|
fi
|
|
;;
|
|
-qtnamespace)
|
|
VAR="qtnamespace"
|
|
shift
|
|
VAL="$1"
|
|
;;
|
|
-qtlibinfix)
|
|
VAR="qtlibinfix"
|
|
shift
|
|
VAL="$1"
|
|
;;
|
|
-D?*|-D)
|
|
VAR="add_define"
|
|
if [ "$1" = "-D" ]; then
|
|
shift
|
|
VAL="$1"
|
|
else
|
|
VAL=`echo $1 | sed 's,-D,,'`
|
|
fi
|
|
;;
|
|
-fpu)
|
|
VAR="fpu"
|
|
# this option may or may not be followed by an argument
|
|
if [ -z "$2" ] || echo "$2" | grep '^-' >/dev/null 2>&1; then
|
|
VAL=no
|
|
else
|
|
shift
|
|
VAL=$1
|
|
fi
|
|
;;
|
|
-I?*|-I)
|
|
VAR="add_ipath"
|
|
if [ "$1" = "-I" ]; then
|
|
shift
|
|
VAL="$1"
|
|
else
|
|
VAL=`echo $1 | sed 's,-I,,'`
|
|
fi
|
|
;;
|
|
-L?*|-L)
|
|
VAR="add_lpath"
|
|
if [ "$1" = "-L" ]; then
|
|
shift
|
|
VAL="$1"
|
|
else
|
|
VAL=`echo $1 | sed 's,-L,,'`
|
|
fi
|
|
;;
|
|
-R?*|-R)
|
|
VAR="add_rpath"
|
|
if [ "$1" = "-R" ]; then
|
|
shift
|
|
VAL="$1"
|
|
else
|
|
VAL=`echo $1 | sed 's,-R,,'`
|
|
fi
|
|
;;
|
|
-l) # -lfoo is handled differently
|
|
VAR="add_link"
|
|
shift
|
|
VAL="$1"
|
|
;;
|
|
-F?*|-F)
|
|
VAR="add_fpath"
|
|
if [ "$1" = "-F" ]; then
|
|
shift
|
|
VAL="$1"
|
|
else
|
|
VAL=`echo $1 | sed 's,-F,,'`
|
|
fi
|
|
;;
|
|
-fw) # -fwfoo is handled differently
|
|
VAR="add_framework"
|
|
shift
|
|
VAL="$1"
|
|
;;
|
|
-W*)
|
|
VAR="add_warn"
|
|
VAL="$1"
|
|
;;
|
|
#General options, including Qt style yes options
|
|
-*)
|
|
VAR=`echo $1 | sed "s,^-\(.*\),\1,"`
|
|
VAL="yes"
|
|
;;
|
|
*)
|
|
UNKNOWN_ARG=yes
|
|
;;
|
|
esac
|
|
if [ "$UNKNOWN_ARG" = "yes" ]; then
|
|
echo "$1: unknown argument"
|
|
ERROR=yes
|
|
shift
|
|
continue
|
|
fi
|
|
shift
|
|
|
|
UNKNOWN_OPT=no
|
|
case "$VAR" in
|
|
accessibility)
|
|
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
|
|
CFG_ACCESSIBILITY="$VAL"
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
license)
|
|
LICENSE_FILE="$VAL"
|
|
;;
|
|
gnumake)
|
|
CFG_USE_GNUMAKE="$VAL"
|
|
;;
|
|
mysql_config)
|
|
CFG_MYSQL_CONFIG="$VAL"
|
|
;;
|
|
prefix)
|
|
QT_INSTALL_PREFIX="$VAL"
|
|
;;
|
|
hostprefix)
|
|
QT_HOST_PREFIX="$VAL"
|
|
;;
|
|
hostdatadir)
|
|
QT_HOST_DATA="$VAL"
|
|
;;
|
|
hostbindir)
|
|
QT_HOST_BINS="$VAL"
|
|
;;
|
|
hostlibdir)
|
|
QT_HOST_LIBS="$VAL"
|
|
;;
|
|
extprefix)
|
|
QT_EXT_PREFIX="$VAL"
|
|
;;
|
|
pkg-config)
|
|
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
|
|
CFG_PKGCONFIG="$VAL"
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
force-pkg-config)
|
|
CFG_PKGCONFIG="force"
|
|
;;
|
|
docdir)
|
|
QT_INSTALL_DOCS="$VAL"
|
|
;;
|
|
headerdir)
|
|
QT_INSTALL_HEADERS="$VAL"
|
|
;;
|
|
plugindir)
|
|
QT_INSTALL_PLUGINS="$VAL"
|
|
;;
|
|
importdir)
|
|
QT_INSTALL_IMPORTS="$VAL"
|
|
;;
|
|
qmldir)
|
|
QT_INSTALL_QML="$VAL"
|
|
;;
|
|
archdatadir)
|
|
QT_INSTALL_ARCHDATA="$VAL"
|
|
;;
|
|
datadir)
|
|
QT_INSTALL_DATA="$VAL"
|
|
;;
|
|
libdir)
|
|
QT_INSTALL_LIBS="$VAL"
|
|
;;
|
|
qtnamespace)
|
|
QT_NAMESPACE="$VAL"
|
|
;;
|
|
qtlibinfix)
|
|
QT_LIBINFIX="$VAL"
|
|
;;
|
|
translationdir)
|
|
QT_INSTALL_TRANSLATIONS="$VAL"
|
|
;;
|
|
sysconfdir|settingsdir)
|
|
QT_INSTALL_SETTINGS="$VAL"
|
|
;;
|
|
examplesdir)
|
|
QT_INSTALL_EXAMPLES="$VAL"
|
|
;;
|
|
testsdir)
|
|
QT_INSTALL_TESTS="$VAL"
|
|
;;
|
|
qconfig)
|
|
CFG_QCONFIG="$VAL"
|
|
;;
|
|
qreal)
|
|
CFG_QREAL="$VAL"
|
|
;;
|
|
sysroot)
|
|
CFG_SYSROOT="$VAL"
|
|
;;
|
|
gcc-sysroot)
|
|
CFG_GCC_SYSROOT="$VAL"
|
|
;;
|
|
bindir)
|
|
QT_INSTALL_BINS="$VAL"
|
|
;;
|
|
libexecdir)
|
|
QT_INSTALL_LIBEXECS="$VAL"
|
|
;;
|
|
sse)
|
|
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
|
|
CFG_SSE="$VAL"
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
opengl)
|
|
if [ "$VAL" = "auto" ] || [ "$VAL" = "desktop" ] ||
|
|
[ "$VAL" = "yes" ] || [ "$VAL" = "no" ] ||
|
|
[ "$VAL" = "es2" ]; then
|
|
CFG_OPENGL="$VAL"
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
openvg)
|
|
if [ "$VAL" = "auto" ] || [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
|
|
CFG_OPENVG="$VAL"
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
nomake)
|
|
if [ -n "${QT_ALL_BUILD_PARTS%%* $VAL *}" ]; then
|
|
echo "Unknown part $VAL passed to -nomake." >&2
|
|
exit 1
|
|
fi
|
|
CFG_NOBUILD_PARTS="$CFG_NOBUILD_PARTS $VAL"
|
|
;;
|
|
make)
|
|
if [ "$VAL" = "no" ]; then
|
|
UNKNOWN_OPT=yes
|
|
else
|
|
if [ -n "${QT_ALL_BUILD_PARTS%%* $VAL *}" ]; then
|
|
echo "Unknown part $VAL passed to -make." >&2
|
|
exit 1
|
|
fi
|
|
CFG_BUILD_PARTS="$CFG_BUILD_PARTS $VAL"
|
|
fi
|
|
;;
|
|
skip)
|
|
VAL=qt${VAL#qt}
|
|
if ! [ -d $relpath/../$VAL ]; then
|
|
echo "Attempting to skip non-existent module $VAL." >&2
|
|
exit 1
|
|
fi
|
|
CFG_SKIP_MODULES="$CFG_SKIP_MODULES $VAL"
|
|
;;
|
|
compile-examples)
|
|
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
|
|
CFG_COMPILE_EXAMPLES="$VAL"
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
sdk)
|
|
if [ "$BUILD_ON_MAC" = "yes" ]; then
|
|
DeviceVar set !host_build:QMAKE_MAC_SDK "$VAL"
|
|
OPT_MAC_SDK="$VAL"
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
arch|host-arch)
|
|
OPT_OBSOLETE_HOST_ARG=yes
|
|
;;
|
|
harfbuzz)
|
|
[ "$VAL" = "yes" ] && VAL=qt
|
|
if [ "$VAL" = "qt" ] || [ "$VAL" = "no" ] || [ "$VAL" = "system" ]; then
|
|
CFG_HARFBUZZ="$VAL"
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
|
|
framework)
|
|
if [ "$BUILD_ON_MAC" = "yes" ]; then
|
|
CFG_FRAMEWORK="$VAL"
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
profile)
|
|
if [ "$VAL" = "yes" ]; then
|
|
CFG_PROFILE=yes
|
|
QMakeVar add QMAKE_CFLAGS -pg
|
|
QMakeVar add QMAKE_CXXFLAGS -pg
|
|
QMakeVar add QMAKE_LFLAGS -pg
|
|
QMAKE_VARS="$QMAKE_VARS CONFIG+=nostrip"
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
strip)
|
|
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
|
|
CFG_STRIP=$VAL
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
testcocoon)
|
|
if [ "$VAL" = "yes" ]; then
|
|
QTCONFIG_CONFIG="$QTCONFIG_CONFIG testcocoon"
|
|
fi
|
|
;;
|
|
gcov)
|
|
if [ "$VAL" = "yes" ]; then
|
|
QTCONFIG_CONFIG="$QTCONFIG_CONFIG gcov"
|
|
fi
|
|
;;
|
|
platform)
|
|
PLATFORM="$VAL"
|
|
# keep compatibility with old platform names
|
|
case $PLATFORM in
|
|
aix-64)
|
|
PLATFORM=aix-xlc-64
|
|
;;
|
|
hpux-o64)
|
|
PLATFORM=hpux-acc-o64
|
|
;;
|
|
hpux-n64)
|
|
PLATFORM=hpux-acc-64
|
|
;;
|
|
hpux-acc-n64)
|
|
PLATFORM=hpux-acc-64
|
|
;;
|
|
irix-n32)
|
|
PLATFORM=irix-cc
|
|
;;
|
|
irix-64)
|
|
PLATFORM=irix-cc-64
|
|
;;
|
|
irix-cc-n64)
|
|
PLATFORM=irix-cc-64
|
|
;;
|
|
reliant-64)
|
|
PLATFORM=reliant-cds-64
|
|
;;
|
|
solaris-64)
|
|
PLATFORM=solaris-cc-64
|
|
;;
|
|
openunix-cc)
|
|
PLATFORM=unixware-cc
|
|
;;
|
|
openunix-g++)
|
|
PLATFORM=unixware-g++
|
|
;;
|
|
unixware7-cc)
|
|
PLATFORM=unixware-cc
|
|
;;
|
|
unixware7-g++)
|
|
PLATFORM=unixware-g++
|
|
;;
|
|
macx-g++-64)
|
|
PLATFORM=macx-g++
|
|
NATIVE_64_ARCH=
|
|
case `uname -p` in
|
|
i386) NATIVE_64_ARCH="x86_64" ;;
|
|
powerpc) NATIVE_64_ARCH="ppc64" ;;
|
|
*) echo "WARNING: Can't detect CPU architecture for macx-g++-64" ;;
|
|
esac
|
|
if [ ! -z "$NATIVE_64_ARCH" ]; then
|
|
QTCONFIG_CONFIG="$QTCONFIG_CONFIG $NATIVE_64_ARCH"
|
|
fi
|
|
;;
|
|
esac
|
|
;;
|
|
xplatform)
|
|
XPLATFORM="$VAL"
|
|
case `basename "$XPLATFORM"` in win32-g++*)
|
|
XPLATFORM_MINGW=yes
|
|
CFG_RPATH=no
|
|
CFG_REDUCE_EXPORTS=no
|
|
;;
|
|
esac
|
|
;;
|
|
device)
|
|
XPLATFORM=`resolveDeviceMkspec $VAL`
|
|
[ "$XPLATFORM" = "undefined" ] && exit 101
|
|
;;
|
|
device-option)
|
|
DEV_VAR=`echo $VAL | cut -d '=' -f 1`
|
|
DEV_VAL=`echo $VAL | cut -d '=' -f 2-`
|
|
DeviceVar set $DEV_VAR "$DEV_VAL"
|
|
;;
|
|
qpa)
|
|
QT_QPA_DEFAULT_PLATFORM="$VAL"
|
|
;;
|
|
debug-and-release)
|
|
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
|
|
CFG_DEBUG_RELEASE="$VAL"
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
optimized-qmake)
|
|
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
|
|
CFG_RELEASE_QMAKE="$VAL"
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
release)
|
|
if [ "$VAL" = "yes" ]; then
|
|
CFG_DEBUG=no
|
|
elif [ "$VAL" = "no" ]; then
|
|
CFG_DEBUG=yes
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
debug)
|
|
CFG_DEBUG="$VAL"
|
|
;;
|
|
force-debug-info)
|
|
CFG_FORCEDEBUGINFO="$VAL"
|
|
;;
|
|
developer-build)
|
|
CFG_DEV="yes"
|
|
;;
|
|
commercial)
|
|
COMMERCIAL_USER="yes"
|
|
;;
|
|
opensource)
|
|
COMMERCIAL_USER="no"
|
|
;;
|
|
static)
|
|
if [ "$VAL" = "yes" ]; then
|
|
CFG_SHARED=no
|
|
elif [ "$VAL" = "no" ]; then
|
|
CFG_SHARED=yes
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
fatal_error)
|
|
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
|
|
CFG_CONFIGURE_EXIT_ON_ERROR="$VAL"
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
feature-*)
|
|
FEATURE=`echo $VAR | sed "s,^[^-]*-\([^-]*\),\1," | tr 'abcdefghijklmnopqrstuvwxyz-' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ_'`
|
|
if [ "$VAL" = "no" ]; then
|
|
QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_$FEATURE"
|
|
elif [ "$VAL" = "yes" ] || [ "$VAL" = "unknown" ]; then
|
|
QCONFIG_FLAGS="$QCONFIG_FLAGS QT_$FEATURE"
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
shared)
|
|
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
|
|
CFG_SHARED="$VAL"
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
gif)
|
|
if [ "$VAL" = "no" ]; then
|
|
CFG_GIF="$VAL"
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
sm)
|
|
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
|
|
CFG_SM="$VAL"
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
|
|
;;
|
|
xinerama)
|
|
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ] || [ "$VAL" = "runtime" ]; then
|
|
CFG_XINERAMA="$VAL"
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
xshape)
|
|
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
|
|
CFG_XSHAPE="$VAL"
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
xvideo)
|
|
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
|
|
CFG_XVIDEO="$VAL"
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
xsync)
|
|
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
|
|
CFG_XSYNC="$VAL"
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
xinput2)
|
|
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
|
|
CFG_XINPUT2="$VAL"
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
xinput)
|
|
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ] || [ "$VAL" = "runtime" ]; then
|
|
CFG_XINPUT="$VAL"
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
egl)
|
|
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
|
|
CFG_EGL="$VAL"
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
glx)
|
|
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
|
|
CFG_GLX="$VAL"
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
pch)
|
|
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
|
|
CFG_PRECOMPILE="$VAL"
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
separate-debug-info)
|
|
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
|
|
CFG_SEPARATE_DEBUG_INFO="$VAL"
|
|
elif [ "$VAL" = "nocopy" ] ; then
|
|
CFG_SEPARATE_DEBUG_INFO="yes"
|
|
CFG_SEPARATE_DEBUG_INFO_NOCOPY="yes"
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
reduce-exports)
|
|
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
|
|
CFG_REDUCE_EXPORTS="$VAL"
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
sse2)
|
|
if [ "$VAL" = "no" ]; then
|
|
CFG_SSE2="$VAL"
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
sse3)
|
|
if [ "$VAL" = "no" ]; then
|
|
CFG_SSE3="$VAL"
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
ssse3)
|
|
if [ "$VAL" = "no" ]; then
|
|
CFG_SSSE3="$VAL"
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
sse4.1)
|
|
if [ "$VAL" = "no" ]; then
|
|
CFG_SSE4_1="$VAL"
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
sse4.2)
|
|
if [ "$VAL" = "no" ]; then
|
|
CFG_SSE4_2="$VAL"
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
avx)
|
|
if [ "$VAL" = "no" ]; then
|
|
CFG_AVX="$VAL"
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
avx2)
|
|
if [ "$VAL" = "no" ]; then
|
|
CFG_AVX2="$VAL"
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
iwmmxt)
|
|
CFG_IWMMXT="yes"
|
|
;;
|
|
neon)
|
|
if [ "$VAL" = "no" ]; then
|
|
CFG_NEON="$VAL"
|
|
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
|
|
;;
|
|
zlib)
|
|
[ "$VAL" = "qt" ] && VAL=yes
|
|
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ] || [ "$VAL" = "system" ]; then
|
|
CFG_ZLIB="$VAL"
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
# No longer supported:
|
|
#[ "$VAL" = "no" ] && CFG_LIBPNG=no
|
|
;;
|
|
sqlite)
|
|
if [ "$VAL" = "system" ]; then
|
|
CFG_SQLITE=system
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
libpng)
|
|
[ "$VAL" = "yes" ] && VAL=qt
|
|
if [ "$VAL" = "qt" ] || [ "$VAL" = "no" ] || [ "$VAL" = "system" ]; then
|
|
CFG_LIBPNG="$VAL"
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
libjpeg)
|
|
[ "$VAL" = "yes" ] && VAL=qt
|
|
if [ "$VAL" = "qt" ] || [ "$VAL" = "no" ] || [ "$VAL" = "system" ]; then
|
|
CFG_LIBJPEG="$VAL"
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
xcursor)
|
|
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ] || [ "$VAL" = "runtime" ]; then
|
|
CFG_XCURSOR="$VAL"
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
xfixes)
|
|
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ] || [ "$VAL" = "runtime" ]; then
|
|
CFG_XFIXES="$VAL"
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
xrandr)
|
|
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ] || [ "$VAL" = "runtime" ]; then
|
|
CFG_XRANDR="$VAL"
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
xrender)
|
|
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
|
|
CFG_XRENDER="$VAL"
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
mitshm)
|
|
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
|
|
CFG_MITSHM="$VAL"
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
fontconfig)
|
|
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
|
|
CFG_FONTCONFIG="$VAL"
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
freetype)
|
|
[ "$VAL" = "yes" ] && VAL=qt
|
|
if [ "$VAL" = "qt" ] || [ "$VAL" = "no" ] || [ "$VAL" = "system" ]; then
|
|
CFG_FREETYPE="$VAL"
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
xkb)
|
|
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
|
|
CFG_XKB="$VAL"
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
xkbcommon)
|
|
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ] || [ "$VAL" = "qt" ] || [ "$VAL" = "system" ]; then
|
|
CFG_XKBCOMMON="$VAL"
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
xcb)
|
|
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ] || [ "$VAL" = "system" ] || [ "$VAL" = "qt" ]; then
|
|
CFG_XCB="$VAL"
|
|
if [ "$VAL" = "yes" ]; then
|
|
CFG_XCB="system"
|
|
fi
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
xcb-xlib)
|
|
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
|
|
CFG_XCB_XLIB="$VAL"
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
wayland)
|
|
CFG_OBSOLETE_WAYLAND=yes
|
|
;;
|
|
eglfs)
|
|
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
|
|
CFG_EGLFS="$VAL"
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
directfb)
|
|
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
|
|
CFG_DIRECTFB="$VAL"
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
linuxfb)
|
|
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
|
|
CFG_LINUXFB="$VAL"
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
kms)
|
|
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
|
|
CFG_KMS="$VAL"
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
libudev)
|
|
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
|
|
CFG_LIBUDEV="$VAL"
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
evdev)
|
|
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
|
|
CFG_EVDEV="$VAL"
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
tslib)
|
|
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
|
|
CFG_TSLIB="$VAL"
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
cups)
|
|
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
|
|
CFG_CUPS="$VAL"
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
iconv)
|
|
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
|
|
CFG_ICONV="$VAL"
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
glib)
|
|
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
|
|
CFG_GLIB="$VAL"
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
slog2)
|
|
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
|
|
CFG_SLOG2="$VAL"
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
pps)
|
|
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
|
|
CFG_PPS="$VAL"
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
gtkstyle)
|
|
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
|
|
CFG_QGTKSTYLE="$VAL"
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
gui)
|
|
if [ "$VAL" = "yes" ] || [ "$VAL" = "auto" ]; then
|
|
CFG_GUI="yes"
|
|
else
|
|
if [ "$VAL" = "no" ]; then
|
|
CFG_GUI="no"
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
fi
|
|
;;
|
|
widgets)
|
|
if [ "$VAL" = "yes" ] || [ "$VAL" = "auto" ]; then
|
|
CFG_WIDGETS="yes"
|
|
elif [ "$VAL" = "no" ]; then
|
|
CFG_WIDGETS="no"
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
qpa-platform-guard)
|
|
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
|
|
QPA_PLATFORM_GUARD="$VAL"
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
dbus)
|
|
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ] || [ "$VAL" = "linked" ]; then
|
|
CFG_DBUS="$VAL"
|
|
elif [ "$VAL" = "runtime" ]; then
|
|
CFG_DBUS="yes"
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
dbus-linked)
|
|
if [ "$VAL" = "yes" ]; then
|
|
CFG_DBUS="linked"
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
nis)
|
|
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
|
|
CFG_NIS="$VAL"
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
largefile)
|
|
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
|
|
CFG_LARGEFILE="$VAL"
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
openssl)
|
|
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
|
|
CFG_OPENSSL="$VAL"
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
openssl-linked)
|
|
if [ "$VAL" = "yes" ]; then
|
|
CFG_OPENSSL="linked"
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
qml-debug)
|
|
if [ "$VAL" = "yes" ]; then
|
|
CFG_QML_DEBUG="yes"
|
|
else
|
|
if [ "$VAL" = "no" ]; then
|
|
CFG_QML_DEBUG="no"
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
fi
|
|
;;
|
|
javascript-jit)
|
|
if [ "$VAL" = "yes" ] || [ "$VAL" = "auto" ] || [ "$VAL" = "no" ]; then
|
|
CFG_JAVASCRIPTCORE_JIT="$VAL"
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
confirm-license)
|
|
if [ "$VAL" = "yes" ]; then
|
|
OPT_CONFIRM_LICENSE="$VAL"
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
h|help)
|
|
if [ "$VAL" = "yes" ]; then
|
|
OPT_HELP="$VAL"
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
sql-*|imageformat-*)
|
|
# if Qt style options were used, $VAL can be "no", "qt", or "plugin"
|
|
# if autoconf style options were used, $VAL can be "yes" or "no"
|
|
[ "$VAL" = "yes" ] && VAL=qt
|
|
# now $VAL should be "no", "qt", or "plugin"... double-check
|
|
if [ "$VAL" != "no" ] && [ "$VAL" != "qt" ] && [ "$VAL" != "plugin" ]; then
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
# now $VAL is "no", "qt", or "plugin"
|
|
OPT="$VAL"
|
|
VAL=`echo $VAR | sed "s,^[^-]*-\([^-]*\).*,\1,"`
|
|
VAR=`echo $VAR | sed "s,^\([^-]*\).*,\1,"`
|
|
|
|
# Grab the available values
|
|
case "$VAR" in
|
|
sql)
|
|
avail="$CFG_SQL_AVAILABLE"
|
|
;;
|
|
imageformat)
|
|
avail="$CFG_IMAGEFORMAT_PLUGIN_AVAILABLE"
|
|
if [ "$OPT" != "plugin" ]; then
|
|
# png is always built in
|
|
avail="$avail png"
|
|
fi
|
|
;;
|
|
*)
|
|
avail=""
|
|
echo "BUG: Unhandled type $VAR used in $CURRENT_OPT"
|
|
;;
|
|
esac
|
|
|
|
# Check that that user's value is available.
|
|
found=no
|
|
for d in $avail; do
|
|
if [ "$VAL" = "$d" ]; then
|
|
found=yes
|
|
break
|
|
fi
|
|
done
|
|
if [ "$found" != "yes" ]; then
|
|
echo "$CURRENT_OPT: unknown argument"
|
|
ERROR=yes
|
|
continue
|
|
fi
|
|
|
|
if [ "$VAR" = "sql" ]; then
|
|
# set the CFG_SQL_driver
|
|
eval "CFG_SQL_$VAL=\$OPT"
|
|
continue
|
|
elif [ "$VAR" = "imageformat" ]; then
|
|
[ "$OPT" = "qt" ] && OPT=yes
|
|
VAL="`echo $VAL |tr a-z A-Z`"
|
|
eval "CFG_$VAL=$OPT"
|
|
continue
|
|
fi
|
|
|
|
if [ "$OPT" = "plugin" ] || [ "$OPT" = "qt" ]; then
|
|
if [ "$OPT" = "plugin" ]; then
|
|
VAR="${VAR}-${OPT}"
|
|
fi
|
|
QMakeVar add "${VAR}s" "${VAL}"
|
|
elif [ "$OPT" = "no" ]; then
|
|
PLUG_VAR="${VAR}-plugin"
|
|
IN_VAR="${VAR}"
|
|
QMakeVar del "${IN_VAR}s" "$VAL"
|
|
QMakeVar del "${PLUG_VAR}s" "$VAL"
|
|
fi
|
|
;;
|
|
v|verbose)
|
|
if [ "$VAL" = "yes" ]; then
|
|
if [ "$OPT_VERBOSE" = "$VAL" ]; then # takes two verboses to turn on qmake debugs
|
|
QMAKE_SWITCHES="$QMAKE_SWITCHES -d"
|
|
else
|
|
OPT_VERBOSE=yes
|
|
fi
|
|
elif [ "$VAL" = "no" ]; then
|
|
if [ "$OPT_VERBOSE" = "$VAL" ] && echo "$QMAKE_SWITCHES" | grep ' -d' >/dev/null 2>&1; then
|
|
QMAKE_SWITCHES=`echo $QMAKE_SWITCHES | sed "s, -d,,"`
|
|
else
|
|
OPT_VERBOSE=no
|
|
fi
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
rpath)
|
|
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
|
|
CFG_RPATH="$VAL"
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
add_define)
|
|
DEFINES="$DEFINES \"$VAL\""
|
|
D_FLAGS="$D_FLAGS -D\"$VAL\""
|
|
;;
|
|
add_ipath)
|
|
I_FLAGS="$I_FLAGS -I\"${VAL}\""
|
|
;;
|
|
add_lpath)
|
|
L_FLAGS="$L_FLAGS -L\"${VAL}\""
|
|
;;
|
|
add_rpath)
|
|
RPATH_FLAGS="$RPATH_FLAGS \"${VAL}\""
|
|
;;
|
|
add_link)
|
|
L_FLAGS="$L_FLAGS -l\"${VAL}\""
|
|
;;
|
|
add_fpath)
|
|
if [ "$BUILD_ON_MAC" = "yes" ]; then
|
|
L_FLAGS="$L_FLAGS -F\"${VAL}\""
|
|
I_FLAGS="$I_FLAGS -F\"${VAL}\""
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
add_framework)
|
|
if [ "$BUILD_ON_MAC" = "yes" ]; then
|
|
L_FLAGS="$L_FLAGS -framework \"${VAL}\""
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
add_warn)
|
|
W_FLAGS="$W_FLAGS \"${VAL}\""
|
|
;;
|
|
silent)
|
|
CFG_SILENT="$VAL"
|
|
;;
|
|
dont-process)
|
|
CFG_PROCESS=no
|
|
;;
|
|
process)
|
|
CFG_PROCESS=partial
|
|
;;
|
|
fully-process)
|
|
CFG_PROCESS=full
|
|
;;
|
|
audio-backend)
|
|
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
|
|
CFG_AUDIO_BACKEND="$VAL"
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
icu)
|
|
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
|
|
CFG_ICU="$VAL"
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
force-asserts)
|
|
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
|
|
CFG_FORCE_ASSERTS="$VAL"
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
pcre)
|
|
if [ "$VAL" = "qt" ] || [ "$VAL" = "system" ]; then
|
|
CFG_PCRE="$VAL"
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
c++11)
|
|
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
|
|
CFG_CXX11="$VAL"
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
system-proxies)
|
|
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
|
|
CFG_SYSTEM_PROXIES="$VAL"
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
directwrite)
|
|
if [ "$XPLATFORM_MINGW" = "yes" ] ; then
|
|
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
|
|
CFG_DIRECTWRITE="$VAL"
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
warnings-are-errors|Werror)
|
|
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
|
|
CFG_WERROR="$VAL"
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
android-sdk)
|
|
CFG_DEFAULT_ANDROID_SDK_ROOT="$VAL"
|
|
;;
|
|
android-ndk)
|
|
CFG_DEFAULT_ANDROID_NDK_ROOT="$VAL"
|
|
;;
|
|
android-ndk-platform)
|
|
CFG_DEFAULT_ANDROID_PLATFORM="$VAL"
|
|
;;
|
|
android-ndk-host)
|
|
CFG_DEFAULT_ANDROID_NDK_HOST="$VAL"
|
|
;;
|
|
android-arch)
|
|
CFG_DEFAULT_ANDROID_TARGET_ARCH="$VAL"
|
|
;;
|
|
android-toolchain-version)
|
|
CFG_DEFAULT_ANDROID_NDK_TOOLCHAIN_VERSION="$VAL"
|
|
;;
|
|
l*) # -lfoo
|
|
if [ "$VAL" = "yes" ]; then
|
|
L_FLAGS="$L_FLAGS -l\"${VAR#l}\""
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
fw*) # -fwfoo
|
|
if [ "$VAL" = "yes" ]; then
|
|
if [ "$BUILD_ON_MAC" = "yes" ]; then
|
|
L_FLAGS="$L_FLAGS -framework \"${VAR#fw}\""
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
else
|
|
UNKNOWN_OPT=yes
|
|
fi
|
|
;;
|
|
*)
|
|
UNKNOWN_OPT=yes
|
|
;;
|
|
esac
|
|
if [ "$UNKNOWN_OPT" = "yes" ]; then
|
|
echo "${CURRENT_OPT}: invalid command-line switch"
|
|
ERROR=yes
|
|
fi
|
|
done
|
|
[ "x$ERROR" = "xyes" ] && exit 1
|
|
|
|
#-------------------------------------------------------------------------------
|
|
# help - interactive parts of the script _after_ this section please
|
|
#-------------------------------------------------------------------------------
|
|
|
|
if [ "$OPT_HELP" = "yes" ]; then
|
|
cat <<EOF
|
|
Usage: $relconf [options]
|
|
|
|
Installation options:
|
|
|
|
These are optional, but you may specify install directories.
|
|
|
|
-prefix <dir> ...... This will install everything relative to <dir>
|
|
(default /usr/local/Qt-${QT_VERSION}, \$PWD if -developer-build is active)
|
|
|
|
-extprefix <dir> ... When -sysroot is used, install everything to <dir>,
|
|
rather than into SYSROOT/PREFIX.
|
|
|
|
-hostprefix [dir] .. Tools and libraries needed when developing
|
|
applications are installed in [dir]. If [dir] is
|
|
not given, the current build directory will be used.
|
|
(default EXTPREFIX)
|
|
|
|
You may use these to separate different parts of the install:
|
|
|
|
-bindir <dir> ......... User executables will be installed to <dir>
|
|
(default PREFIX/bin)
|
|
-headerdir <dir> ...... Headers will be installed to <dir>
|
|
(default PREFIX/include)
|
|
-libdir <dir> ......... Libraries will be installed to <dir>
|
|
(default PREFIX/lib)
|
|
-archdatadir <dir> .... Arch-dependent data used by Qt will be installed to <dir>
|
|
(default PREFIX)
|
|
-plugindir <dir> ...... Plugins will be installed to <dir>
|
|
(default ARCHDATADIR/plugins)
|
|
-libexecdir <dir> ..... Program executables will be installed to <dir>
|
|
(default ARCHDATADIR/libexec, ARCHDATADIR/bin for MinGW)
|
|
-importdir <dir> ...... Imports for QML1 will be installed to <dir>
|
|
(default ARCHDATADIR/imports)
|
|
-qmldir <dir> ......... Imports for QML2 will be installed to <dir>
|
|
(default ARCHDATADIR/qml)
|
|
-datadir <dir> ........ Arch-independent data used by Qt will be installed to <dir>
|
|
(default PREFIX)
|
|
-docdir <dir> ......... Documentation will be installed to <dir>
|
|
(default DATADIR/doc)
|
|
-translationdir <dir> . Translations of Qt programs will be installed to <dir>
|
|
(default DATADIR/translations)
|
|
-sysconfdir <dir> ..... Settings used by Qt programs will be looked for in <dir>
|
|
(default PREFIX/etc/xdg)
|
|
-examplesdir <dir> .... Examples will be installed to <dir>
|
|
(default PREFIX/examples)
|
|
-testsdir <dir> ....... Tests will be installed to <dir>
|
|
(default PREFIX/tests)
|
|
|
|
-hostbindir <dir> .. Host executables will be installed to <dir>
|
|
(default HOSTPREFIX/bin)
|
|
-hostlibdir <dir> .. Host libraries will be installed to <dir>
|
|
(default HOSTPREFIX/lib)
|
|
-hostdatadir <dir> . Data used by qmake will be installed to <dir>
|
|
(default HOSTPREFIX)
|
|
|
|
Configure options:
|
|
|
|
The defaults (*) are usually acceptable. A plus (+) denotes a default value
|
|
that needs to be evaluated. If the evaluation succeeds, the feature is
|
|
included. Here is a short explanation of each option:
|
|
|
|
* -release ........... Compile and link Qt with debugging turned off.
|
|
-debug ............. Compile and link Qt with debugging turned on.
|
|
-debug-and-release . Compile and link two versions of Qt, with and without
|
|
debugging turned on (Mac only).
|
|
|
|
-force-debug-info .. Create symbol files for release builds.
|
|
|
|
-developer-build ... Compile and link Qt with Qt developer options (including auto-tests exporting)
|
|
|
|
-opensource ........ Compile and link the Open-Source Edition of Qt.
|
|
-commercial ........ Compile and link the Commercial Edition of Qt.
|
|
|
|
-confirm-license ... Automatically acknowledge the license (use with
|
|
either -opensource or -commercial)
|
|
|
|
-no-c++11 .......... Do not compile Qt with C++11 support enabled.
|
|
+ -c++11 ............. Compile Qt with C++11 support enabled.
|
|
|
|
* -shared ............ Create and use shared Qt libraries.
|
|
-static ............ Create and use static Qt libraries.
|
|
|
|
* -process ........... Generate only a top-level Makefile.
|
|
-fully-process ..... Generate Makefiles for the entire Qt tree.
|
|
-dont-process ...... Do not generate any Makefiles.
|
|
|
|
-no-largefile ...... Disables large file support.
|
|
+ -largefile ......... Enables Qt to access files larger than 4 GB.
|
|
|
|
-no-accessibility .. Do not compile Accessibility support.
|
|
Disabling accessibility is not recommended, as it will break QStyle
|
|
and may break other internal parts of Qt.
|
|
With this switch you create a source incompatible version of Qt,
|
|
which is unsupported.
|
|
+ -accessibility ..... Compile Accessibility support.
|
|
|
|
-no-sql-<driver> ... Disable SQL <driver> entirely.
|
|
-qt-sql-<driver> ... Enable a SQL <driver> in the Qt SQL module, by default
|
|
none are turned on.
|
|
-plugin-sql-<driver> Enable SQL <driver> as a plugin to be linked to
|
|
at run time.
|
|
|
|
Possible values for <driver>:
|
|
[$CFG_SQL_AVAILABLE ]
|
|
|
|
-system-sqlite ..... Use sqlite from the operating system.
|
|
|
|
-no-javascript-jit . Do not build the JavaScriptCore JIT compiler.
|
|
+ -javascript-jit .... Build the JavaScriptCore JIT compiler.
|
|
|
|
-no-qml-debug ...... Do not build the in-process QML debugging support.
|
|
+ -qml-debug ......... Build the QML debugging support.
|
|
|
|
-platform target ... The operating system and compiler you are building
|
|
on (default detected from host system).
|
|
|
|
See the README file for a list of supported
|
|
operating systems and compilers.
|
|
|
|
-no-sse2 ........... Do not compile with use of SSE2 instructions.
|
|
-no-sse3 ........... Do not compile with use of SSE3 instructions.
|
|
-no-ssse3 .......... Do not compile with use of SSSE3 instructions.
|
|
-no-sse4.1 ......... Do not compile with use of SSE4.1 instructions.
|
|
-no-sse4.2 ......... Do not compile with use of SSE4.2 instructions.
|
|
-no-avx ............ Do not compile with use of AVX instructions.
|
|
-no-avx2 ........... Do not compile with use of AVX2 instructions.
|
|
-no-neon ........... Do not compile with use of NEON instructions.
|
|
-no-mips_dsp ....... Do not compile with use of MIPS DSP instructions.
|
|
-no-mips_dspr2 ..... Do not compile with use of MIPS DSP rev2 instructions.
|
|
|
|
-qtnamespace <name> Wraps all Qt library code in 'namespace <name> {...}'.
|
|
-qtlibinfix <infix> Renames all libQt*.so to libQt*<infix>.so.
|
|
|
|
-testcocoon ........ Instrument Qt with the TestCocoon code coverage tool.
|
|
-gcov .............. Instrument Qt with the GCov code coverage tool.
|
|
|
|
-D <string> ........ Add an explicit define to the preprocessor.
|
|
-I <string> ........ Add an explicit include path.
|
|
-L <string> ........ Add an explicit library path.
|
|
|
|
+ -pkg-config ........ Use pkg-config to detect include and library paths. By default,
|
|
configure determines whether to use pkg-config or not with
|
|
some heuristics such as checking the environment variables.
|
|
-no-pkg-config ..... Disable use of pkg-config.
|
|
-force-pkg-config .. Force usage of pkg-config (skips pkg-config usability
|
|
detection heuristic).
|
|
|
|
-help, -h .......... Display this information.
|
|
|
|
Third Party Libraries:
|
|
|
|
-qt-zlib ........... Use the zlib bundled with Qt.
|
|
+ -system-zlib ....... Use zlib from the operating system.
|
|
See http://www.gzip.org/zlib
|
|
|
|
-no-gif ............ Do not compile GIF reading support.
|
|
|
|
-no-libpng ......... Do not compile PNG support.
|
|
-qt-libpng ......... Use the libpng bundled with Qt.
|
|
+ -system-libpng ..... Use libpng from the operating system.
|
|
See http://www.libpng.org/pub/png
|
|
|
|
-no-libjpeg ........ Do not compile JPEG support.
|
|
-qt-libjpeg ........ Use the libjpeg bundled with Qt.
|
|
+ -system-libjpeg .... Use libjpeg from the operating system.
|
|
See http://www.ijg.org
|
|
|
|
-no-freetype ....... Do not compile in Freetype2 support.
|
|
-qt-freetype ....... Use the libfreetype bundled with Qt.
|
|
+ -system-freetype.... Use the libfreetype provided by the system (enabled if -fontconfig is active).
|
|
See http://www.freetype.org
|
|
|
|
* -no-harfbuzz ....... Do not compile HarfBuzz-NG support.
|
|
-qt-harfbuzz ....... (experimental) Use HarfBuzz-NG bundled with Qt
|
|
to do text shaping. It can still be disabled
|
|
by setting QT_HARFBUZZ environment variable to "old".
|
|
-system-harfbuzz ... (experimental) Use HarfBuzz-NG from the operating system
|
|
to do text shaping. It can still be disabled
|
|
by setting QT_HARFBUZZ environment variable to "old".
|
|
|
|
-no-openssl ........ Do not compile support for OpenSSL.
|
|
+ -openssl ........... Enable run-time OpenSSL support.
|
|
-openssl-linked .... Enabled linked OpenSSL support.
|
|
|
|
-qt-pcre ........... Use the PCRE library bundled with Qt.
|
|
+ -system-pcre ....... Use the PCRE library from the operating system.
|
|
|
|
-qt-xcb ............ Use xcb- libraries bundled with Qt.
|
|
(libxcb.so will still be used from operating system).
|
|
+ -system-xcb ........ Use xcb- libraries from the operating system.
|
|
|
|
-qt-xkbcommon ...... Use the xkbcommon library bundled with Qt.
|
|
+ -system-xkbcommon .. Use the xkbcommon library from the operating system.
|
|
|
|
-no-xinput2 ........ Do not compile XInput2 support.
|
|
* -xinput2 ........... Compile XInput2 support.
|
|
|
|
-no-xcb-xlib........ Do not compile Xcb-Xlib support.
|
|
* -xcb-xlib........... Compile Xcb-Xlib support.
|
|
|
|
-no-glib ........... Do not compile Glib support.
|
|
+ -glib .............. Compile Glib support.
|
|
|
|
Additional options:
|
|
|
|
-make <part> ....... Add part to the list of parts to be built at make time.
|
|
(defaults to: $QT_DEFAULT_BUILD_PARTS)
|
|
-nomake <part> ..... Exclude part from the list of parts to be built.
|
|
|
|
-skip <module> ..... Exclude an entire module from the build.
|
|
|
|
-no-compile-examples ... Install only the sources of examples.
|
|
|
|
-no-gui ............ Don't build the Qt GUI module and dependencies.
|
|
+ -gui ............... Build the Qt GUI module and dependencies.
|
|
|
|
-no-widgets ........ Don't build the Qt Widgets module and dependencies.
|
|
+ -widgets ........... Build the Qt Widgets module and dependencies.
|
|
|
|
-R <string> ........ Add an explicit runtime library path to the Qt
|
|
libraries.
|
|
-l <string> ........ Add an explicit library.
|
|
|
|
-no-rpath .......... Do not use the library install path as a runtime
|
|
library path.
|
|
+ -rpath ............. Link Qt libraries and executables using the library
|
|
install path as a runtime library path. Equivalent
|
|
to -R install_libpath
|
|
|
|
-continue .......... Continue as far as possible if an error occurs.
|
|
|
|
-verbose, -v ....... Print verbose information about each step of the
|
|
configure process.
|
|
|
|
-silent ............ Reduce the build output so that warnings and errors
|
|
can be seen more easily.
|
|
|
|
* -no-optimized-qmake ... Do not build qmake optimized.
|
|
-optimized-qmake ...... Build qmake optimized.
|
|
|
|
-no-nis ............ Do not compile NIS support.
|
|
* -nis ............... Compile NIS support.
|
|
|
|
-no-cups ........... Do not compile CUPS support.
|
|
* -cups .............. Compile CUPS support.
|
|
Requires cups/cups.h and libcups.so.2.
|
|
|
|
-no-iconv .......... Do not compile support for iconv(3).
|
|
* -iconv ............. Compile support for iconv(3).
|
|
|
|
-no-icu ............ Do not compile support for ICU libraries.
|
|
+ -icu ............... Compile support for ICU libraries.
|
|
|
|
-no-fontconfig ..... Do not compile FontConfig support.
|
|
+ -fontconfig ........ Compile FontConfig support.
|
|
|
|
-no-strip .......... Do not strip binaries and libraries of unneeded symbols.
|
|
* -strip ............. Strip binaries and libraries of unneeded symbols when installing.
|
|
|
|
* -no-pch ............ Do not use precompiled header support.
|
|
-pch ............... Use precompiled header support.
|
|
|
|
-no-dbus ........... Do not compile the Qt D-Bus module.
|
|
+ -dbus .............. Compile the Qt D-Bus module and dynamically load libdbus-1.
|
|
-dbus-linked ....... Compile the Qt D-Bus module and link to libdbus-1.
|
|
|
|
-reduce-relocations ..... Reduce relocations in the libraries through extra
|
|
linker optimizations (Qt/X11 and Qt for Embedded Linux only;
|
|
experimental; needs GNU ld >= 2.18).
|
|
|
|
-force-asserts ........ Force Q_ASSERT to be enabled even in release builds.
|
|
|
|
-device <name> ............... Cross-compile for device <name> (experimental)
|
|
-device-option <key=value> ... Add device specific options for the device mkspec
|
|
(experimental)
|
|
|
|
-no-separate-debug-info . Do not store debug information in a separate file.
|
|
* -separate-debug-info .... Strip debug information into a separate file.
|
|
|
|
-no-xcb ............ Do not compile Xcb (X protocol C-language Binding) support.
|
|
* -xcb ............... Compile Xcb support.
|
|
|
|
-no-eglfs .......... Do not compile EGLFS (EGL Full Screen/Single Surface) support.
|
|
* -eglfs ............. Compile EGLFS support.
|
|
|
|
-no-directfb ....... Do not compile DirectFB support.
|
|
* -directfb .......... Compile DirectFB support.
|
|
|
|
-no-linuxfb ........ Do not compile Linux Framebuffer support.
|
|
* -linuxfb ........... Compile Linux Framebuffer support.
|
|
|
|
-no-kms ............ Do not compile KMS support.
|
|
* -kms ............... Compile KMS support (Requires EGL).
|
|
|
|
-qpa <name> ......... Sets the default QPA platform (e.g xcb, cocoa, windows).
|
|
|
|
-xplatform target ... The target platform when cross-compiling.
|
|
|
|
-sysroot <dir> ...... Sets <dir> as the target compiler's and qmake's sysroot and also sets pkg-config paths.
|
|
-no-gcc-sysroot ..... When using -sysroot, it disables the passing of --sysroot to the compiler
|
|
|
|
-no-feature-<feature> Do not compile in <feature>.
|
|
-feature-<feature> .. Compile in <feature>. The available features
|
|
are described in src/corelib/global/qfeatures.txt
|
|
|
|
-qconfig local ...... Use src/corelib/global/qconfig-local.h rather than the
|
|
default ($CFG_QCONFIG).
|
|
|
|
-qreal [double|float] typedef qreal to the specified type. The default is double.
|
|
Note that changing this flag affects binary compatibility.
|
|
|
|
-no-opengl .......... Do not support OpenGL.
|
|
-opengl <api> ....... Enable OpenGL support
|
|
With no parameter, this will attempt to auto-detect
|
|
OpenGL ES 2, or regular desktop OpenGL.
|
|
Use es2 for <api> to override auto-detection.
|
|
|
|
* -no-system-proxies .. Do not use system network proxies by default.
|
|
-system-proxies ..... Use system network proxies by default.
|
|
|
|
-no-warnings-are-errors Make warnings be treated normally
|
|
-warnings-are-errors Make warnings be treated as errors
|
|
(enabled if -developer-build is active)
|
|
|
|
QNX/Blackberry options:
|
|
|
|
-no-slog2 .......... Do not compile with slog2 support.
|
|
-slog2 ............. Compile with slog2 support.
|
|
|
|
-no-pps ............ Do not compile with pps support.
|
|
-pps ............... Compile with pps support.
|
|
|
|
MacOS/iOS options:
|
|
|
|
-Fstring ........... Add an explicit framework path.
|
|
-fw string ......... Add an explicit framework.
|
|
|
|
* -framework ......... Build Qt as a series of frameworks and
|
|
link tools against those frameworks.
|
|
-no-framework ...... Do not build Qt as a series of frameworks.
|
|
|
|
-sdk <sdk> ......... Build Qt using Apple provided SDK <sdk>. The argument should be
|
|
one of the available SDKs as listed by 'xcodebuild -showsdks'.
|
|
Note that the argument applies only to Qt libraries and applications built
|
|
using the target mkspec - not host tools such as qmake, moc, rcc, etc.
|
|
|
|
Android options:
|
|
|
|
-android-sdk path .............. The Android SDK root path.
|
|
(default \$ANDROID_SDK_ROOT)
|
|
|
|
-android-ndk path .............. The Android NDK root path.
|
|
(default \$ANDROID_NDK_ROOT)
|
|
|
|
-android-ndk-platform .......... Sets the android platform
|
|
(default $CFG_DEFAULT_ANDROID_PLATFORM)
|
|
|
|
-android-ndk-host .............. Sets the android NDK host (linux-x86, linux-x86_64, etc.)
|
|
(default \$ANDROID_NDK_HOST)
|
|
|
|
-android-arch .................. Sets the android architecture (armeabi, armeabi-v7a, x86, mips)
|
|
(default $CFG_DEFAULT_ANDROID_TARGET_ARCH)
|
|
|
|
-android-toolchain-version ..... Sets the android toolchain version
|
|
(default $CFG_DEFAULT_ANDROID_NDK_TOOLCHAIN_VERSION)
|
|
EOF
|
|
|
|
exit 0
|
|
fi # Help
|
|
|
|
#-------------------------------------------------------------------------------
|
|
# platform detection
|
|
#-------------------------------------------------------------------------------
|
|
|
|
if [ -z "$PLATFORM" ]; then
|
|
PLATFORM_NOTES=
|
|
case "$UNAME_SYSTEM:$UNAME_RELEASE" in
|
|
Darwin:*)
|
|
# Select compiler. Use g++ unless we find a usable Clang version. Note that
|
|
# we are checking the "Apple" clang/LLVM version number, not the actual
|
|
# clang/LLVM version number that the Apple version was based on. We look
|
|
# for Apple clang version 3.0 or higher, which was branched off LLVM 3.0
|
|
# from SVN, and first included in Xcode 4.2. Also note that we do not care
|
|
# about the OS version, since we're not using the clang version that comes
|
|
# with the system. We use 'xcrun' to check the clang version that's part of
|
|
# the Xcode installation.
|
|
XCRUN=`/usr/bin/xcrun -sdk macosx clang -v 2>&1`
|
|
CLANGVERSION=`echo "$XCRUN" | sed -n 's/.*version \([0-9]\).*/\1/p'`
|
|
expr "$CLANGVERSION" : '[0-9]' > /dev/null || { echo "Unable to determine CLANG version from output of xcrun: $XCRUN" ; exit 2 ; }
|
|
if [ "$CLANGVERSION" -ge 3 ]; then
|
|
PLATFORM=macx-clang
|
|
|
|
# Advertise g++ as an alternative on Lion and below
|
|
if [ "$(uname -r | cut -d. -f1)" -le 11 ]; then
|
|
PLATFORM_NOTES="\n - Also available for Mac OS X: macx-g++\n"
|
|
fi
|
|
else
|
|
PLATFORM=macx-g++
|
|
fi
|
|
;;
|
|
AIX:*)
|
|
#PLATFORM=aix-g++
|
|
#PLATFORM=aix-g++-64
|
|
PLATFORM=aix-xlc
|
|
#PLATFORM=aix-xlc-64
|
|
PLATFORM_NOTES="
|
|
- Also available for AIX: aix-g++ aix-g++-64 aix-xlc-64
|
|
"
|
|
;;
|
|
GNU:*)
|
|
PLATFORM=hurd-g++
|
|
;;
|
|
dgux:*)
|
|
PLATFORM=dgux-g++
|
|
;;
|
|
# DYNIX/ptx:4*)
|
|
# PLATFORM=dynix-g++
|
|
# ;;
|
|
ULTRIX:*)
|
|
PLATFORM=ultrix-g++
|
|
;;
|
|
FreeBSD:*)
|
|
PLATFORM=freebsd-g++
|
|
PLATFORM_NOTES="
|
|
- Also available for FreeBSD: freebsd-icc
|
|
"
|
|
;;
|
|
OpenBSD:*)
|
|
PLATFORM=openbsd-g++
|
|
;;
|
|
NetBSD:*)
|
|
PLATFORM=netbsd-g++
|
|
;;
|
|
BSD/OS:*|BSD/386:*)
|
|
PLATFORM=bsdi-g++
|
|
;;
|
|
IRIX*:*)
|
|
#PLATFORM=irix-g++
|
|
PLATFORM=irix-cc
|
|
#PLATFORM=irix-cc-64
|
|
PLATFORM_NOTES="
|
|
- Also available for IRIX: irix-g++ irix-cc-64
|
|
"
|
|
;;
|
|
HP-UX:*)
|
|
case "$UNAME_MACHINE" in
|
|
ia64)
|
|
#PLATFORM=hpuxi-acc-32
|
|
PLATFORM=hpuxi-acc-64
|
|
PLATFORM_NOTES="
|
|
- Also available for HP-UXi: hpuxi-acc-32
|
|
"
|
|
;;
|
|
*)
|
|
#PLATFORM=hpux-g++
|
|
PLATFORM=hpux-acc
|
|
#PLATFORM=hpux-acc-64
|
|
#PLATFORM=hpux-cc
|
|
#PLATFORM=hpux-acc-o64
|
|
PLATFORM_NOTES="
|
|
- Also available for HP-UX: hpux-g++ hpux-acc-64 hpux-acc-o64
|
|
"
|
|
;;
|
|
esac
|
|
;;
|
|
OSF1:*)
|
|
#PLATFORM=tru64-g++
|
|
PLATFORM=tru64-cxx
|
|
PLATFORM_NOTES="
|
|
- Also available for Tru64: tru64-g++
|
|
"
|
|
;;
|
|
Linux:*)
|
|
PLATFORM=linux-g++
|
|
PLATFORM_NOTES="
|
|
- Also available for Linux: linux-kcc linux-icc linux-cxx
|
|
"
|
|
;;
|
|
SunOS:5*)
|
|
if [ "$XPLATFORM_MINGW" = "yes" ]; then
|
|
PLATFORM="solaris-g++"
|
|
else
|
|
#PLATFORM=solaris-g++
|
|
PLATFORM=solaris-cc
|
|
#PLATFORM=solaris-cc64
|
|
fi
|
|
PLATFORM_NOTES="
|
|
- Also available for Solaris: solaris-g++ solaris-cc-64
|
|
"
|
|
;;
|
|
ReliantUNIX-*:*|SINIX-*:*)
|
|
PLATFORM=reliant-cds
|
|
#PLATFORM=reliant-cds-64
|
|
PLATFORM_NOTES="
|
|
- Also available for Reliant UNIX: reliant-cds-64
|
|
"
|
|
;;
|
|
CYGWIN*:*)
|
|
PLATFORM=cygwin-g++
|
|
;;
|
|
LynxOS*:*)
|
|
PLATFORM=lynxos-g++
|
|
;;
|
|
OpenUNIX:*)
|
|
#PLATFORM=unixware-g++
|
|
PLATFORM=unixware-cc
|
|
PLATFORM_NOTES="
|
|
- Also available for OpenUNIX: unixware-g++
|
|
"
|
|
;;
|
|
UnixWare:*)
|
|
#PLATFORM=unixware-g++
|
|
PLATFORM=unixware-cc
|
|
PLATFORM_NOTES="
|
|
- Also available for UnixWare: unixware-g++
|
|
"
|
|
;;
|
|
SCO_SV:*)
|
|
#PLATFORM=sco-g++
|
|
PLATFORM=sco-cc
|
|
PLATFORM_NOTES="
|
|
- Also available for SCO OpenServer: sco-g++
|
|
"
|
|
;;
|
|
UNIX_SV:*)
|
|
PLATFORM=unixware-g++
|
|
;;
|
|
QNX:*)
|
|
PLATFORM=unsupported/qnx-g++
|
|
;;
|
|
*)
|
|
echo >&2
|
|
echo " The build script does not currently recognize all" >&2
|
|
echo " platforms supported by Qt." >&2
|
|
echo " Rerun this script with a -platform option listed to" >&2
|
|
echo " set the system/compiler combination you use." >&2
|
|
echo >&2
|
|
exit 2
|
|
esac
|
|
fi
|
|
|
|
[ -z "$XPLATFORM" ] && XPLATFORM="$PLATFORM"
|
|
|
|
case "$XPLATFORM" in
|
|
*win32-g++*)
|
|
XPLATFORM_MINGW=yes
|
|
;;
|
|
*-maemo*)
|
|
XPLATFORM_MAEMO=yes
|
|
;;
|
|
*qnx-*|*blackberry-*)
|
|
XPLATFORM_QNX=yes
|
|
;;
|
|
*ios*)
|
|
XPLATFORM_MAC=yes
|
|
XPLATFORM_IOS=yes
|
|
;;
|
|
*macx*)
|
|
XPLATFORM_MAC=yes
|
|
;;
|
|
# XPLATFORM_ANDROID should not be set for unsupported/android-g++
|
|
*unsupported*)
|
|
;;
|
|
*android-g++*)
|
|
XPLATFORM_ANDROID=yes
|
|
;;
|
|
esac
|
|
|
|
#-------------------------------------------------------------------------------
|
|
# check the license
|
|
#-------------------------------------------------------------------------------
|
|
|
|
if [ "$COMMERCIAL_USER" = "ask" ]; then
|
|
while true; do
|
|
echo "Which edition of Qt do you want to use ?"
|
|
echo
|
|
echo "Type 'c' if you want to use the Commercial Edition."
|
|
echo "Type 'o' if you want to use the Open Source Edition."
|
|
echo
|
|
read commercial
|
|
echo
|
|
if [ "$commercial" = "c" ]; then
|
|
COMMERCIAL_USER="yes"
|
|
break
|
|
elif [ "$commercial" = "o" ]; then
|
|
COMMERCIAL_USER="no"
|
|
break
|
|
fi
|
|
done
|
|
fi
|
|
|
|
CFG_RTOS_ENABLED=yes
|
|
EditionString=Commercial
|
|
if [ -f "$relpath"/LICENSE.PREVIEW.COMMERCIAL ] && [ $COMMERCIAL_USER = "yes" ]; then
|
|
# Commercial preview release
|
|
Licensee="Preview"
|
|
Edition="Preview"
|
|
QT_EDITION="QT_EDITION_DESKTOP"
|
|
LicenseType="Technology Preview"
|
|
elif [ $COMMERCIAL_USER = "yes" ]; then
|
|
# one of commercial editions
|
|
|
|
# read in the license file
|
|
[ -z "$LICENSE_FILE" ] && LICENSE_FILE="$QT_LICENSE_FILE"
|
|
[ -z "$LICENSE_FILE" ] && LICENSE_FILE="$HOME/.qt-license"
|
|
if [ -f "$LICENSE_FILE" ]; then
|
|
tr -d '\r' <"$LICENSE_FILE" >"${LICENSE_FILE}.tmp"
|
|
diff "${LICENSE_FILE}.tmp" "${LICENSE_FILE}" >/dev/null 2>&1 || LICENSE_FILE="${LICENSE_FILE}.tmp"
|
|
. "$LICENSE_FILE" >/dev/null 2>&1
|
|
if [ -z "$LicenseKeyExt" ]; then
|
|
echo
|
|
echo "You are using an old license file."
|
|
echo
|
|
echo "Please install the license file supplied by Digia,"
|
|
echo "or install the Qt Open Source Edition if you intend to"
|
|
echo "develop free software."
|
|
exit 1
|
|
fi
|
|
if [ -z "$Licensee" ]; then
|
|
echo
|
|
echo "Invalid license key. Please check the license key."
|
|
exit 1
|
|
fi
|
|
else
|
|
if [ -z "$LicenseKeyExt" ]; then
|
|
echo
|
|
echo $ECHO_N "Please enter your license key: $ECHO_C"
|
|
read LicenseKeyExt
|
|
Licensee="Unknown user"
|
|
fi
|
|
fi
|
|
|
|
# Key verification
|
|
echo "$LicenseKeyExt" | grep ".....*-....*-....*-....*-.....*-.....*-...." >/dev/null 2>&1 \
|
|
&& LicenseValid="yes" \
|
|
|| LicenseValid="no"
|
|
if [ "$LicenseValid" != "yes" ]; then
|
|
echo
|
|
echo "Invalid license key. Please check the license key."
|
|
exit 1
|
|
fi
|
|
ProductCode=`echo $LicenseKeyExt | cut -f 1 -d - | cut -b 1`
|
|
PlatformCode=`echo $LicenseKeyExt | cut -f 2 -d -`
|
|
LicenseTypeCode=`echo $LicenseKeyExt | cut -f 3 -d -`
|
|
LicenseFeatureCode=`echo $LicenseKeyExt | cut -f 4 -d - | cut -b 1`
|
|
|
|
# determine which edition we are licensed to use
|
|
case "$LicenseTypeCode" in
|
|
F4M)
|
|
LicenseType="Commercial"
|
|
case $ProductCode in
|
|
F)
|
|
Edition="Universal"
|
|
QT_EDITION="QT_EDITION_UNIVERSAL"
|
|
;;
|
|
B)
|
|
Edition="FullFramework"
|
|
EditionString="Full Framework"
|
|
QT_EDITION="QT_EDITION_DESKTOP"
|
|
;;
|
|
L)
|
|
Edition="GUIFramework"
|
|
EditionString="GUI Framework"
|
|
QT_EDITION="QT_EDITION_DESKTOPLIGHT"
|
|
;;
|
|
esac
|
|
;;
|
|
Z4M|R4M|Q4M)
|
|
LicenseType="Evaluation"
|
|
QMakeVar add DEFINES QT_EVAL
|
|
case $ProductCode in
|
|
B)
|
|
Edition="Evaluation"
|
|
QT_EDITION="QT_EDITION_EVALUATION"
|
|
;;
|
|
esac
|
|
;;
|
|
esac
|
|
if [ -z "$LicenseType" -o -z "$Edition" -o -z "$QT_EDITION" ]; then
|
|
echo
|
|
echo "Invalid license key. Please check the license key."
|
|
exit 1
|
|
fi
|
|
|
|
# verify that we are licensed to use Qt on this platform
|
|
LICENSE_EXTENSION=
|
|
case "$PlatformCode" in
|
|
*L)
|
|
CFG_RTOS_ENABLED=yes
|
|
PlatformCode=`echo "$PlatformCode" | sed 'h;y/8NPQRTZ/UCWX9M7/;x;G;s/\(.\)....\(.\)./\1\2/'`
|
|
;;
|
|
*)
|
|
CFG_RTOS_ENABLED=no
|
|
PlatformCode=`echo "$PlatformCode" | sed 's/.$//'`
|
|
;;
|
|
esac
|
|
### EMBEDDED_QPA logic missing ###
|
|
case "$PlatformCode,$XPLATFORM_MAC" in
|
|
X9,* | XC,* | XU,* | XW,* | XM,*)
|
|
# Qt All-OS
|
|
LICENSE_EXTENSION="-ALLOS"
|
|
;;
|
|
8M,* | KM,* | S9,* | SC,* | SM,* | SU,* | SW,* | X9,* | XC,* | XU,* | XW,*)
|
|
# Qt for Embedded Linux
|
|
LICENSE_EXTENSION="-EMBEDDED"
|
|
;;
|
|
6M,* | N7,* | N9,* | NX,*)
|
|
# Embedded no-deploy
|
|
LICENSE_EXTENSION="-EMBEDDED"
|
|
;;
|
|
FM,* | LM,yes | ZM,no)
|
|
# Desktop
|
|
LICENSE_EXTENSION="-DESKTOP"
|
|
;;
|
|
*)
|
|
Platform=Linux/X11
|
|
[ "$XPLATFORM_MAC" = "yes" ] && Platform='Mac OS X'
|
|
echo
|
|
echo "You are not licensed for the $Platform platform."
|
|
echo
|
|
echo "Please use the contact form at http://qt.digia.com/contact-us"
|
|
echo "to upgrade your license to include the $Platform platform, or install"
|
|
echo "the Qt Open Source Edition if you intend to develop free software."
|
|
exit 1
|
|
;;
|
|
esac
|
|
|
|
if test -r "$relpath/.LICENSE"; then
|
|
# Generic, non-final license
|
|
LICENSE_EXTENSION=""
|
|
line=`sed 'y/a-z/A-Z/;q' "$relpath"/.LICENSE`
|
|
case "$line" in
|
|
*BETA*)
|
|
Edition=Beta
|
|
;;
|
|
*TECHNOLOGY?PREVIEW*)
|
|
Edition=Preview
|
|
;;
|
|
*EVALUATION*)
|
|
Edition=Evaluation
|
|
;;
|
|
*)
|
|
echo >&2 "Invalid license files; cannot continue"
|
|
exit 1
|
|
;;
|
|
esac
|
|
Licensee="$Edition"
|
|
EditionString="$Edition"
|
|
QT_EDITION="QT_EDITION_DESKTOP"
|
|
fi
|
|
|
|
case "$LicenseFeatureCode" in
|
|
B|G|L|Y)
|
|
# US
|
|
case "$LicenseType" in
|
|
Commercial)
|
|
cp -f "$relpath/.LICENSE${LICENSE_EXTENSION}-US" "$outpath/LICENSE"
|
|
;;
|
|
Evaluation)
|
|
cp -f "$relpath/.LICENSE-EVALUATION-US" "$outpath/LICENSE"
|
|
;;
|
|
esac
|
|
;;
|
|
2|4|5|F)
|
|
# non-US
|
|
case "$LicenseType" in
|
|
Commercial)
|
|
cp -f "$relpath/.LICENSE${LICENSE_EXTENSION}" "$outpath/LICENSE"
|
|
;;
|
|
Evaluation)
|
|
cp -f "$relpath/.LICENSE-EVALUATION" "$outpath/LICENSE"
|
|
;;
|
|
esac
|
|
;;
|
|
*)
|
|
echo
|
|
echo "Invalid license key. Please check the license key."
|
|
exit 1
|
|
;;
|
|
esac
|
|
case "$LicenseFeatureCode" in
|
|
4|B|F|Y)
|
|
CFG_RTOS_ENABLED=yes
|
|
;;
|
|
2|5|G|L)
|
|
CFG_RTOS_ENABLED=no
|
|
;;
|
|
esac
|
|
if [ '!' -f "$outpath/LICENSE" ]; then
|
|
echo "The LICENSE, LICENSE.GPL3 LICENSE.LGPL file shipped with"
|
|
echo "this software has disappeared."
|
|
echo
|
|
echo "Sorry, you are not licensed to use this software."
|
|
echo "Try re-installing."
|
|
echo
|
|
exit 1
|
|
fi
|
|
elif [ $COMMERCIAL_USER = "no" ]; then
|
|
# Open Source edition - may only be used under the terms of the GPL or LGPL.
|
|
Licensee="Open Source"
|
|
Edition="OpenSource"
|
|
EditionString="Open Source"
|
|
QT_EDITION="QT_EDITION_OPENSOURCE"
|
|
fi
|
|
echo
|
|
echo "This is the Qt ${EditionString} Edition."
|
|
echo
|
|
|
|
if [ "$CFG_RTOS_ENABLED" = "no" ]; then
|
|
case `basename "$XPLATFORM"` in
|
|
qnx-* | vxworks-*)
|
|
echo ""
|
|
echo "You are not licensed for Qt for `basename $XPLATFORM`."
|
|
echo ""
|
|
echo "Please use the contact form at http://qt.digia.com/contact-us"
|
|
echo "to upgrade your license to include this platform, or install"
|
|
echo "the Qt Open Source Edition if you intend to develop free software."
|
|
exit 1
|
|
;;
|
|
esac
|
|
fi
|
|
|
|
if [ "$Edition" = "OpenSource" ]; then
|
|
while true; do
|
|
echo "You are licensed to use this software under the terms of"
|
|
echo "the Lesser GNU General Public License (LGPL) versions 2.1."
|
|
if [ -f "$relpath/LICENSE.GPL3" ]; then
|
|
echo "You are also licensed to use this software under the terms of"
|
|
echo "the GNU General Public License (GPL) versions 3."
|
|
affix="either"
|
|
else
|
|
affix="the"
|
|
fi
|
|
echo
|
|
if [ "$OPT_CONFIRM_LICENSE" = "yes" ]; then
|
|
echo "You have already accepted the terms of the $LicenseType license."
|
|
acceptance=yes
|
|
else
|
|
if [ -f "$relpath/LICENSE.GPL3" ]; then
|
|
echo "Type '3' to view the GNU General Public License version 3."
|
|
fi
|
|
echo "Type 'L' to view the Lesser GNU General Public License version 2.1."
|
|
echo "Type 'yes' to accept this license offer."
|
|
echo "Type 'no' to decline this license offer."
|
|
echo
|
|
echo $ECHO_N "Do you accept the terms of $affix license? $ECHO_C"
|
|
read acceptance
|
|
fi
|
|
echo
|
|
if [ "$acceptance" = "yes" ] || [ "$acceptance" = "y" ]; then
|
|
break
|
|
elif [ "$acceptance" = "no" ]; then
|
|
echo "You are not licensed to use this software."
|
|
echo
|
|
exit 1
|
|
elif [ "$acceptance" = "3" ]; then
|
|
more "$relpath/LICENSE.GPL3"
|
|
elif [ "$acceptance" = "L" ]; then
|
|
more "$relpath/LICENSE.LGPL"
|
|
fi
|
|
done
|
|
elif [ "$Edition" = "Preview" ]; then
|
|
TheLicense=`head -n 1 "$relpath/LICENSE.PREVIEW.COMMERCIAL"`
|
|
while true; do
|
|
|
|
if [ "$OPT_CONFIRM_LICENSE" = "yes" ]; then
|
|
echo "You have already accepted the terms of the $LicenseType license."
|
|
acceptance=yes
|
|
else
|
|
echo "You are licensed to use this software under the terms of"
|
|
echo "the $TheLicense"
|
|
echo
|
|
echo "Type '?' to read the Preview License."
|
|
echo "Type 'yes' to accept this license offer."
|
|
echo "Type 'no' to decline this license offer."
|
|
echo
|
|
echo $ECHO_N "Do you accept the terms of the license? $ECHO_C"
|
|
read acceptance
|
|
fi
|
|
echo
|
|
if [ "$acceptance" = "yes" ]; then
|
|
break
|
|
elif [ "$acceptance" = "no" ] ;then
|
|
echo "You are not licensed to use this software."
|
|
echo
|
|
exit 0
|
|
elif [ "$acceptance" = "?" ]; then
|
|
more "$relpath/LICENSE.PREVIEW.COMMERCIAL"
|
|
fi
|
|
done
|
|
elif [ "$Edition" != "OpenSource" ]; then
|
|
if [ -n "$ExpiryDate" ]; then
|
|
ExpiryDate=`echo $ExpiryDate | sed -e "s,-,,g" | tr -d "\n\r"`
|
|
[ -z "$ExpiryDate" ] && ExpiryDate="0"
|
|
Today=`date +%Y%m%d`
|
|
if [ "$Today" -gt "$ExpiryDate" ]; then
|
|
case "$LicenseType" in
|
|
Commercial|Academic|Educational)
|
|
echo
|
|
echo "WARNING WARNING WARNING WARNING"
|
|
echo
|
|
echo " Your support and upgrade period has expired."
|
|
echo
|
|
echo " You may continue to use your last licensed release"
|
|
echo " of Qt under the terms of your existing license"
|
|
echo " agreement. But you are not entitled to technical"
|
|
echo " support, nor are you entitled to use any more recent"
|
|
echo " Qt releases."
|
|
echo
|
|
echo " Please use the contact form at http://qt.digia.com/contact-us"
|
|
echo " to renew your support and upgrades for this license."
|
|
echo
|
|
echo "WARNING WARNING WARNING WARNING"
|
|
echo
|
|
sleep 3
|
|
;;
|
|
Evaluation|*)
|
|
echo
|
|
echo "NOTICE NOTICE NOTICE NOTICE"
|
|
echo
|
|
echo " Your Evaluation license has expired."
|
|
echo
|
|
echo " You are no longer licensed to use this software. Please"
|
|
echo " use the contact form at http://qt.digia.com/contact-us to"
|
|
echo " purchase license, or install the Qt Open Source Edition"
|
|
echo " if you intend to develop free software."
|
|
echo
|
|
echo "NOTICE NOTICE NOTICE NOTICE"
|
|
echo
|
|
exit 1
|
|
;;
|
|
esac
|
|
fi
|
|
fi
|
|
TheLicense=`head -n 1 "$outpath/LICENSE"`
|
|
while true; do
|
|
if [ "$OPT_CONFIRM_LICENSE" = "yes" ]; then
|
|
echo "You have already accepted the terms of the $TheLicense."
|
|
acceptance=yes
|
|
else
|
|
echo "You are licensed to use this software under the terms of"
|
|
echo "the $TheLicense."
|
|
echo
|
|
echo "Type '?' to view the $TheLicense."
|
|
echo "Type 'yes' to accept this license offer."
|
|
echo "Type 'no' to decline this license offer."
|
|
echo
|
|
echo $ECHO_N "Do you accept the terms of the $TheLicense? $ECHO_C"
|
|
read acceptance
|
|
fi
|
|
echo
|
|
if [ "$acceptance" = "yes" ]; then
|
|
break
|
|
elif [ "$acceptance" = "no" ]; then
|
|
echo "You are not licensed to use this software."
|
|
echo
|
|
exit 1
|
|
else [ "$acceptance" = "?" ]
|
|
more "$outpath/LICENSE"
|
|
fi
|
|
done
|
|
fi
|
|
|
|
#-------------------------------------------------------------------------------
|
|
# command line and environment validation
|
|
#-------------------------------------------------------------------------------
|
|
|
|
# update QT_CONFIG to show our current predefined configuration
|
|
CFG_QCONFIG_PATH=$relpath/src/corelib/global/qconfig-${CFG_QCONFIG}.h
|
|
case "$CFG_QCONFIG" in
|
|
minimal|small|medium|large|full)
|
|
# these are a sequence of increasing functionality
|
|
for c in minimal small medium large full; do
|
|
QT_CONFIG="$QT_CONFIG $c-config"
|
|
[ "$CFG_QCONFIG" = $c ] && break
|
|
done
|
|
[ "$CFG_QCONFIG" = full ] && CFG_QCONFIG_PATH=
|
|
;;
|
|
*)
|
|
# not known to be sufficient for anything
|
|
if [ ! -f "$CFG_QCONFIG_PATH" ]; then
|
|
CFG_QCONFIG_PATH=`"$relpath/config.tests/unix/makeabs" "${CFG_QCONFIG}"`
|
|
if [ ! -f "$CFG_QCONFIG_PATH" ]; then
|
|
echo >&2 "Error: configuration file not found:"
|
|
echo >&2 " $relpath/src/corelib/global/qconfig-${CFG_QCONFIG}.h"
|
|
echo >&2 " or"
|
|
echo >&2 " $CFG_QCONFIG_PATH"
|
|
exit 1
|
|
fi
|
|
fi
|
|
esac
|
|
|
|
if [ "$XPLATFORM_MAC" = "no" -a "$CFG_DEBUG_RELEASE" = "yes" ]; then
|
|
echo
|
|
echo "WARNING: -debug-and-release is not supported outside of Mac OS X."
|
|
echo "Qt can be built in release mode with separate debug information, so"
|
|
echo "-debug-and-release is not necessary anymore"
|
|
echo
|
|
fi
|
|
|
|
if [ "$CFG_XCB" != "no" ] && [ "$CFG_XKBCOMMON" = "no" ]; then
|
|
echo "Error: -no-xkbcommon is not supported on XCB platform plugin."
|
|
exit 101
|
|
fi
|
|
|
|
if [ "$XPLATFORM_ANDROID" = "yes" ]; then
|
|
if [ -z "$CFG_DEFAULT_ANDROID_NDK_HOST" ]; then
|
|
case $PLATFORM in
|
|
linux-*)
|
|
if [ -d "$CFG_DEFAULT_ANDROID_NDK_ROOT/toolchains/arm-linux-androideabi-$CFG_DEFAULT_ANDROID_NDK_TOOLCHAIN_VERSION/prebuilt/linux-x86" ]; then
|
|
CFG_DEFAULT_ANDROID_NDK_HOST=linux-x86
|
|
elif [ -d "$CFG_DEFAULT_ANDROID_NDK_ROOT/toolchains/arm-linux-androideabi-$CFG_DEFAULT_ANDROID_NDK_TOOLCHAIN_VERSION/prebuilt/linux-x86_64" ]; then
|
|
CFG_DEFAULT_ANDROID_NDK_HOST=linux-x86_64
|
|
fi
|
|
;;
|
|
macx-*)
|
|
CFG_DEFAULT_ANDROID_NDK_HOST=darwin-x86
|
|
if [ ! -z "$NATIVE_64_ARCH" ] && [ -d "$CFG_DEFAULT_ANDROID_NDK_ROOT/toolchains/arm-linux-androideabi-$CFG_DEFAULT_ANDROID_NDK_TOOLCHAIN_VERSION/prebuilt/darwin-x86_64" ]; then
|
|
CFG_DEFAULT_ANDROID_NDK_HOST=darwin-x86_64
|
|
fi
|
|
;;
|
|
win32-*)
|
|
CFG_DEFAULT_ANDROID_NDK_HOST=windows
|
|
if [ ! -z "$NATIVE_64_ARCH" ] && [ -d "$CFG_DEFAULT_ANDROID_NDK_ROOT/toolchains/arm-linux-androideabi-$CFG_DEFAULT_ANDROID_NDK_TOOLCHAIN_VERSION/prebuilt/windows-x86_64" ]; then
|
|
CFG_DEFAULT_ANDROID_NDK_HOST=windows-x86_64
|
|
fi
|
|
;;
|
|
esac
|
|
fi
|
|
|
|
if [ -z "$CFG_DEFAULT_ANDROID_NDK_ROOT" ]; then
|
|
echo
|
|
echo "Can not find Android NDK. Please use -android-ndk option to specify one"
|
|
exit 1
|
|
fi
|
|
if [ -z "$CFG_DEFAULT_ANDROID_SDK_ROOT" ]; then
|
|
echo
|
|
echo "Can not find Android SDK. Please use -android-sdk option to specify one"
|
|
exit 1
|
|
fi
|
|
if [ -z "CFG_DEFAULT_ANDROID_NDK_TOOLCHAIN_VERSION" ] || [ ! -d "$CFG_DEFAULT_ANDROID_NDK_ROOT/toolchains/arm-linux-androideabi-$CFG_DEFAULT_ANDROID_NDK_TOOLCHAIN_VERSION/prebuilt" ]; then
|
|
echo
|
|
echo "Can not detect Android NDK toolchain. Please use -android-toolchain-version to specify"
|
|
exit 1
|
|
fi
|
|
if [ -z "$CFG_DEFAULT_ANDROID_NDK_HOST" ] || [ ! -d "$CFG_DEFAULT_ANDROID_NDK_ROOT/toolchains/arm-linux-androideabi-$CFG_DEFAULT_ANDROID_NDK_TOOLCHAIN_VERSION/prebuilt/$CFG_DEFAULT_ANDROID_NDK_HOST" ]; then
|
|
echo
|
|
echo "Can not detect the android host. Please use -android-ndk-host option to specify one"
|
|
exit 1
|
|
fi
|
|
|
|
QT_QPA_DEFAULT_PLATFORM="android"
|
|
CFG_LARGEFILE="no"
|
|
|
|
DeviceVar set DEFAULT_ANDROID_SDK_ROOT "$CFG_DEFAULT_ANDROID_SDK_ROOT"
|
|
DeviceVar set DEFAULT_ANDROID_NDK_ROOT "$CFG_DEFAULT_ANDROID_NDK_ROOT"
|
|
DeviceVar set DEFAULT_ANDROID_PLATFORM "$CFG_DEFAULT_ANDROID_PLATFORM"
|
|
DeviceVar set DEFAULT_ANDROID_NDK_HOST "$CFG_DEFAULT_ANDROID_NDK_HOST"
|
|
DeviceVar set DEFAULT_ANDROID_TARGET_ARCH "$CFG_DEFAULT_ANDROID_TARGET_ARCH"
|
|
DeviceVar set DEFAULT_ANDROID_NDK_TOOLCHAIN_VERSION "$CFG_DEFAULT_ANDROID_NDK_TOOLCHAIN_VERSION"
|
|
fi
|
|
|
|
if [ -d "$PLATFORM" ]; then
|
|
QMAKESPEC="$PLATFORM"
|
|
else
|
|
QMAKESPEC="$relpath/mkspecs/${PLATFORM}"
|
|
fi
|
|
if [ -d "$XPLATFORM" ]; then
|
|
XQMAKESPEC="$XPLATFORM"
|
|
else
|
|
XQMAKESPEC="$relpath/mkspecs/${XPLATFORM}"
|
|
fi
|
|
if [ "$PLATFORM" != "$XPLATFORM" ]; then
|
|
QT_CROSS_COMPILE=yes
|
|
QMAKE_CONFIG="$QMAKE_CONFIG cross_compile"
|
|
QTCONFIG_CONFIG="$QTCONFIG_CONFIG cross_compile"
|
|
fi
|
|
|
|
if [ "$BUILD_ON_MAC" = "yes" ]; then
|
|
if [ `basename $QMAKESPEC` = "macx-xcode" ] || [ `basename $XQMAKESPEC` = "macx-xcode" ]; then
|
|
echo >&2
|
|
echo " Platform 'macx-xcode' should not be used when building Qt/Mac." >&2
|
|
echo " Please build Qt/Mac with 'macx-clang' or 'macx-g++', then use" >&2
|
|
echo " the 'macx-xcode' spec for your application, and it will link to" >&2
|
|
echo " the Qt/Mac build using the settings of the original mkspec." >&2
|
|
echo >&2
|
|
exit 2
|
|
fi
|
|
fi
|
|
|
|
# check specified platforms are supported
|
|
if [ '!' -d "$QMAKESPEC" ]; then
|
|
echo
|
|
echo " The specified system/compiler is not supported:"
|
|
echo
|
|
echo " $QMAKESPEC"
|
|
echo
|
|
echo " Please see the README file for a complete list."
|
|
echo
|
|
exit 2
|
|
fi
|
|
if [ '!' -d "$XQMAKESPEC" ]; then
|
|
echo
|
|
echo " The specified system/compiler is not supported:"
|
|
echo
|
|
echo " $XQMAKESPEC"
|
|
echo
|
|
echo " Please see the README file for a complete list."
|
|
echo
|
|
exit 2
|
|
fi
|
|
if [ '!' -f "${XQMAKESPEC}/qplatformdefs.h" ]; then
|
|
echo
|
|
echo " The specified system/compiler port is not complete:"
|
|
echo
|
|
echo " $XQMAKESPEC/qplatformdefs.h"
|
|
echo
|
|
echo " Please use the contact form at http://qt.digia.com/contact-us"
|
|
echo
|
|
exit 2
|
|
fi
|
|
|
|
#-------------------------------------------------------------------------------
|
|
# build tree initialization
|
|
#-------------------------------------------------------------------------------
|
|
|
|
# is this a shadow build?
|
|
if [ "$OPT_SHADOW" = "maybe" ]; then
|
|
OPT_SHADOW=no
|
|
if [ "$relpath" != "$outpath" ] && [ '!' -f "$outpath/configure" ]; then
|
|
if [ -h "$outpath" ]; then
|
|
[ "$relpath" -ef "$outpath" ] || OPT_SHADOW=yes
|
|
else
|
|
OPT_SHADOW=yes
|
|
fi
|
|
fi
|
|
fi
|
|
if [ "$OPT_SHADOW" = "yes" ]; then
|
|
if [ -f "$relpath/.qmake.cache" -o -f "$relpath/src/corelib/global/qconfig.h" -o -f "$relpath/src/corelib/global/qconfig.cpp" ]; then
|
|
echo >&2 "You cannot make a shadow build from a source tree containing a previous build."
|
|
echo >&2 "Cannot proceed."
|
|
exit 1
|
|
fi
|
|
[ "$OPT_VERBOSE" = "yes" ] && echo "Performing shadow build..."
|
|
fi
|
|
|
|
# if the source tree is different from the build tree,
|
|
# symlink or copy part of the sources
|
|
if [ "$OPT_SHADOW" = "yes" ]; then
|
|
echo "Preparing build tree..."
|
|
|
|
[ -d "$outpath/bin" ] || mkdir -p "$outpath/bin"
|
|
|
|
mkdir -p "$outpath/mkspecs"
|
|
fi
|
|
|
|
# symlink fonts to be able to run application from build directory
|
|
if [ ! -d "${outpath}/lib/fonts" ]; then
|
|
if [ "$PLATFORM" = "$XPLATFORM" ]; then
|
|
mkdir -p "${outpath}/lib"
|
|
ln -s "${relpath}/lib/fonts" "${outpath}/lib/fonts"
|
|
fi
|
|
fi
|
|
|
|
#-------------------------------------------------------------------------------
|
|
# tests that don't need qmake (must be run before displaying help)
|
|
#-------------------------------------------------------------------------------
|
|
|
|
# detect build style
|
|
if [ "$CFG_DEBUG" = "auto" ]; then
|
|
if [ "$XPLATFORM_MAC" = "yes" -o "$XPLATFORM_MINGW" = "yes" ]; then
|
|
CFG_DEBUG_RELEASE=yes
|
|
CFG_DEBUG=yes
|
|
elif [ "$CFG_DEV" = "yes" ]; then
|
|
CFG_DEBUG_RELEASE=no
|
|
CFG_DEBUG=yes
|
|
else
|
|
CFG_DEBUG_RELEASE=no
|
|
CFG_DEBUG=no
|
|
fi
|
|
fi
|
|
if [ "$CFG_DEBUG_RELEASE" = "yes" ]; then
|
|
QT_CONFIG="$QT_CONFIG build_all debug_and_release"
|
|
fi
|
|
|
|
if [ "$CFG_FORCEDEBUGINFO" = "yes" ]; then
|
|
QMAKE_CONFIG="$QMAKE_CONFIG force_debug_info"
|
|
fi
|
|
|
|
if [ "$XPLATFORM_IOS" = "yes" ]; then
|
|
CFG_RPATH="no"
|
|
CFG_PKGCONFIG="no"
|
|
CFG_NOBUILD_PARTS="$CFG_NOBUILD_PARTS examples tests"
|
|
CFG_SHARED="no" # iOS builds should be static to be able to submit to the App Store
|
|
CFG_CXX11="no" # C++11 support disabled for now
|
|
CFG_SKIP_MODULES="$CFG_SKIP_MODULES qtconnectivity qtdoc qtlocation qtmacextras qtserialport qttools qtwebkit qtwebkit-examples"
|
|
|
|
# If the user passes -sdk on the command line we build a SDK-specific Qt build.
|
|
# Otherwise we build a joined simulator and device build, which is the default.
|
|
if [ -z "$OPT_MAC_SDK" ]; then
|
|
QT_CONFIG="$QT_CONFIG build_all"
|
|
QTCONFIG_CONFIG="$QTCONFIG_CONFIG iphonesimulator_and_iphoneos"
|
|
fi
|
|
fi
|
|
|
|
# disable GTK style support auto-detection on Mac
|
|
if [ "$XPLATFORM_MAC" = "yes" ] && [ "$CFG_QGTKSTYLE" = "auto" ]; then
|
|
CFG_QGTKSTYLE=no
|
|
fi
|
|
|
|
QMAKE_CONF_COMPILER=`getXQMakeConf QMAKE_CXX`
|
|
|
|
TEST_COMPILER=$QMAKE_CONF_COMPILER
|
|
|
|
if [ "$XPLATFORM_ANDROID" = "yes" ] ; then
|
|
ANDROID_NDK_TOOLS_PREFIX=
|
|
ANDROID_PLATFORM_ARCH=
|
|
case $CFG_DEFAULT_ANDROID_TARGET_ARCH in
|
|
armeabi*)
|
|
ANDROID_NDK_TOOLS_PREFIX=arm-linux-androideabi
|
|
ANDROID_PLATFORM_ARCH=arch-arm
|
|
;;
|
|
x86)
|
|
ANDROID_NDK_TOOLS_PREFIX=x86
|
|
ANDROID_PLATFORM_ARCH=arch-x86
|
|
;;
|
|
mips)
|
|
ANDROID_NDK_TOOLS_PREFIX=mipsel-linux-android
|
|
ANDROID_PLATFORM_ARCH=arch-mips
|
|
;;
|
|
*)
|
|
echo "ERROR: Unknown android arch $CFG_DEFAULT_ANDROID_TARGET_ARCH"
|
|
exit 1
|
|
;;
|
|
esac
|
|
QMAKE_CONF_COMPILER=$CFG_DEFAULT_ANDROID_NDK_ROOT/toolchains/$ANDROID_NDK_TOOLS_PREFIX-$CFG_DEFAULT_ANDROID_NDK_TOOLCHAIN_VERSION/prebuilt/$CFG_DEFAULT_ANDROID_NDK_HOST/bin/$ANDROID_NDK_TOOLS_PREFIX-g++
|
|
TEST_COMPILER="$QMAKE_CONF_COMPILER --sysroot=$CFG_DEFAULT_ANDROID_NDK_ROOT/platforms/$CFG_DEFAULT_ANDROID_PLATFORM/$ANDROID_PLATFORM_ARCH/"
|
|
fi
|
|
|
|
if [ "$XPLATFORM_SYMBIAN_SBSV2" = "no" ]; then
|
|
if [ -z "$TEST_COMPILER" ]; then
|
|
echo "ERROR: Cannot set the compiler for the configuration tests"
|
|
exit 1
|
|
fi
|
|
fi
|
|
TEST_COMPILER_CXXFLAGS=`getXQMakeConf QMAKE_CXXFLAGS`
|
|
|
|
GCC_MACHINE_DUMP=
|
|
case "$TEST_COMPILER" in *g++) GCC_MACHINE_DUMP=$($TEST_COMPILER -dumpmachine);; esac
|
|
if [ -n "$GCC_MACHINE_DUMP" ]; then
|
|
DeviceVar set GCC_MACHINE_DUMP $($TEST_COMPILER -dumpmachine)
|
|
fi
|
|
|
|
if [ -n "$CFG_SYSROOT" ] && [ "$CFG_GCC_SYSROOT" = "yes" ]; then
|
|
SYSROOT_FLAG="--sysroot=$CFG_SYSROOT"
|
|
else
|
|
SYSROOT_FLAG=
|
|
fi
|
|
export SYSROOT_FLAG # used by config.tests/unix/{compile.test,arch.test}
|
|
|
|
# auto-detect precompiled header support
|
|
if [ "$CFG_PRECOMPILE" = "auto" ]; then
|
|
if "$unixtests/precomp.test" "$TEST_COMPILER" "$OPT_VERBOSE"; then
|
|
CFG_PRECOMPILE=no
|
|
else
|
|
CFG_PRECOMPILE=yes
|
|
fi
|
|
fi
|
|
|
|
# auto-detect support for separate debug info in objcopy
|
|
if [ "$CFG_SEPARATE_DEBUG_INFO" != "no" ] && [ "$CFG_SHARED" = "yes" ]; then
|
|
TEST_OBJCOPY=`getXQMakeConf QMAKE_OBJCOPY`
|
|
COMPILER_WITH_FLAGS="$TEST_COMPILER $TEST_COMPILER_CXXFLAGS"
|
|
if "$unixtests/objcopy.test" "$COMPILER_WITH_FLAGS" "$TEST_OBJCOPY" "$OPT_VERBOSE"; then
|
|
CFG_SEPARATE_DEBUG_INFO=no
|
|
else
|
|
case "$PLATFORM" in
|
|
hpux-*)
|
|
# binutils on HP-UX is buggy; default to no.
|
|
CFG_SEPARATE_DEBUG_INFO=no
|
|
;;
|
|
*)
|
|
CFG_SEPARATE_DEBUG_INFO=yes
|
|
;;
|
|
esac
|
|
fi
|
|
fi
|
|
|
|
# auto-detect -fvisibility support
|
|
if [ "$CFG_REDUCE_EXPORTS" != "no" ]; then
|
|
if "$unixtests/fvisibility.test" "$TEST_COMPILER" "$OPT_VERBOSE"; then
|
|
if [ "$CFG_REDUCE_EXPORTS" = "yes" ]; then
|
|
echo "-reduce-exports was requested but this compiler does not support it"
|
|
echo "Re-run configure with -v for more information"
|
|
exit 1
|
|
fi
|
|
CFG_REDUCE_EXPORTS=no
|
|
else
|
|
CFG_REDUCE_EXPORTS=yes
|
|
fi
|
|
fi
|
|
|
|
# auto-detect -fstack-protector-strong support (for QNX only currently)
|
|
if [ "$XPLATFORM_QNX" = "yes" ]; then
|
|
if compilerSupportsFlag $TEST_COMPILER -fstack-protector-strong; then
|
|
CFG_STACK_PROTECTOR_STRONG=yes
|
|
else
|
|
CFG_STACK_PROTECTOR_STRONG=no
|
|
fi
|
|
else
|
|
CFG_STACK_PROTECTOR_STRONG=no
|
|
fi
|
|
|
|
# detect the availability of the -Bsymbolic-functions linker optimization
|
|
if [ "$CFG_REDUCE_RELOCATIONS" != "no" ]; then
|
|
if "$unixtests/bsymbolic_functions.test" "$TEST_COMPILER" "$OPT_VERBOSE"; then
|
|
if [ "$CFG_REDUCE_RELOCATIONS" = "yes" ]; then
|
|
echo "-reduce-relocations was requested but this compiler does not support it"
|
|
echo "Re-run configure with -v for more information"
|
|
exit 1
|
|
fi
|
|
CFG_REDUCE_RELOCATIONS=no
|
|
else
|
|
CFG_REDUCE_RELOCATIONS=yes
|
|
fi
|
|
fi
|
|
|
|
# auto-detect GNU make support
|
|
if [ "$CFG_USE_GNUMAKE" = "auto" ] && "$MAKE" -v | grep "GNU Make" >/dev/null 2>&1; then
|
|
CFG_USE_GNUMAKE=yes
|
|
fi
|
|
|
|
# find the default framework value
|
|
if [ "$XPLATFORM_MAC" = "yes" ]; then
|
|
if [ "$CFG_FRAMEWORK" = "auto" ]; then
|
|
CFG_FRAMEWORK="$CFG_SHARED"
|
|
elif [ "$CFG_FRAMEWORK" = "yes" ] && [ "$CFG_SHARED" = "no" ]; then
|
|
echo
|
|
echo "WARNING: Using static linking will disable the use of Mac frameworks."
|
|
echo
|
|
CFG_FRAMEWORK="no"
|
|
fi
|
|
else
|
|
CFG_FRAMEWORK=no
|
|
fi
|
|
|
|
# Auto-detect default include and library search paths.
|
|
|
|
# Use intermediate variable to get around backtick/quote nesting problems.
|
|
awkprog='
|
|
BEGIN { ORS = ""; FS = "="; incs = 0; libs = 0; }
|
|
|
|
function normalize(dir)
|
|
{
|
|
do {
|
|
odir = dir
|
|
gsub(/\/[^\/]+\/\.\./, "", dir)
|
|
} while (dir != odir);
|
|
do {
|
|
odir = dir
|
|
gsub(/\/\./, "", dir)
|
|
} while (dir != odir);
|
|
sub("/$", "", dir);
|
|
return dir;
|
|
}
|
|
|
|
# extract include paths from indented lines between
|
|
# #include <...> search starts here:
|
|
# and
|
|
# End of search list.
|
|
/^\#include </ { yup=1; print "DEFAULT_INCDIRS=\""; next }
|
|
/^End of search/ { yup=0; print "\"\n" }
|
|
/ \(framework directory\)$/ { next }
|
|
yup { print normalize(substr($0, 2)) "\n"; ++incs }
|
|
|
|
# extract from one line like LIBRARY_PATH=/one/path:/another/path:...
|
|
$1 == "LIBRARY_PATH" {
|
|
libs = split($2, library_paths, ":");
|
|
print "DEFAULT_LIBDIRS=\"";
|
|
for (lib in library_paths) {
|
|
dir = normalize(library_paths[lib]);
|
|
if (!(dir in dirs)) {
|
|
print dir "\n";
|
|
dirs[dir] = 1;
|
|
}
|
|
}
|
|
print "\"\n"
|
|
}
|
|
|
|
END {
|
|
if (incs == 0)
|
|
print "DEFAULT_INCDIRS=\"/usr/include\n/usr/local/include\"\n";
|
|
if (libs == 0)
|
|
print "DEFAULT_LIBDIRS=\"/lib\n/usr/lib\"\n";
|
|
}'
|
|
|
|
unset tty
|
|
[ "$OPT_VERBOSE" = "yes" ] && tty=/dev/stderr
|
|
eval "`LC_ALL=C $TEST_COMPILER $SYSROOT_FLAG $TEST_COMPILER_CXXFLAGS -xc++ -E -v - < /dev/null 2>&1 > /dev/null | $AWK "$awkprog" | tee $tty`"
|
|
unset tty
|
|
|
|
#setup the build parts
|
|
if [ -z "$CFG_BUILD_PARTS" ]; then
|
|
CFG_BUILD_PARTS="$QT_DEFAULT_BUILD_PARTS"
|
|
|
|
# build tests by default, if a developer build
|
|
if [ "$CFG_DEV" = "yes" ]; then
|
|
CFG_BUILD_PARTS="$CFG_BUILD_PARTS tests"
|
|
fi
|
|
|
|
# don't build tools by default when cross-compiling
|
|
if [ "$PLATFORM" != "$XPLATFORM" ]; then
|
|
CFG_BUILD_PARTS=`echo "$CFG_BUILD_PARTS" | sed "s, tools,,g"`
|
|
fi
|
|
fi
|
|
for nobuild in $CFG_NOBUILD_PARTS; do
|
|
CFG_BUILD_PARTS=`echo "$CFG_BUILD_PARTS" | sed "s, $nobuild,,g"`
|
|
done
|
|
if echo $CFG_BUILD_PARTS | grep -v libs >/dev/null 2>&1; then
|
|
# echo
|
|
# echo "WARNING: libs is a required part of the build."
|
|
# echo
|
|
CFG_BUILD_PARTS="$CFG_BUILD_PARTS libs"
|
|
fi
|
|
|
|
#-------------------------------------------------------------------------------
|
|
# post process QT_INSTALL_* variables
|
|
#-------------------------------------------------------------------------------
|
|
|
|
if [ -z "$QT_INSTALL_PREFIX" ]; then
|
|
if [ "$CFG_DEV" = "yes" ]; then
|
|
QT_INSTALL_PREFIX="$outpath" # In Development, we use sandboxed builds by default
|
|
else
|
|
QT_INSTALL_PREFIX="/usr/local/Qt-${QT_VERSION}" # the default install prefix is /usr/local/Qt-$QT_VERSION
|
|
fi
|
|
fi
|
|
QT_INSTALL_PREFIX=`"$relpath/config.tests/unix/makeabs" "$QT_INSTALL_PREFIX"`
|
|
|
|
if [ -z "$QT_INSTALL_HEADERS" ]; then #default
|
|
QT_INSTALL_HEADERS="$QT_INSTALL_PREFIX/include"
|
|
fi
|
|
QT_INSTALL_HEADERS=`"$relpath/config.tests/unix/makeabs" "$QT_INSTALL_HEADERS"`
|
|
|
|
if [ -z "$QT_INSTALL_LIBS" ]; then #default
|
|
QT_INSTALL_LIBS="$QT_INSTALL_PREFIX/lib" #fallback
|
|
fi
|
|
QT_INSTALL_LIBS=`"$relpath/config.tests/unix/makeabs" "$QT_INSTALL_LIBS"`
|
|
|
|
if [ -z "$QT_INSTALL_ARCHDATA" ]; then #default
|
|
QT_INSTALL_ARCHDATA="$QT_INSTALL_PREFIX" #fallback
|
|
fi
|
|
QT_INSTALL_ARCHDATA=`"$relpath/config.tests/unix/makeabs" "$QT_INSTALL_ARCHDATA"`
|
|
|
|
if [ -z "$QT_INSTALL_DATA" ]; then #default
|
|
QT_INSTALL_DATA="$QT_INSTALL_PREFIX" #fallback
|
|
fi
|
|
QT_INSTALL_DATA=`"$relpath/config.tests/unix/makeabs" "$QT_INSTALL_DATA"`
|
|
|
|
if [ -z "$QT_INSTALL_BINS" ]; then #default
|
|
QT_INSTALL_BINS="$QT_INSTALL_PREFIX/bin" #fallback
|
|
fi
|
|
QT_INSTALL_BINS=`"$relpath/config.tests/unix/makeabs" "$QT_INSTALL_BINS"`
|
|
|
|
if [ "$XPLATFORM_MINGW" = "yes" ]; then
|
|
QT_INSTALL_LIBEXECS_DIRNAME="bin"
|
|
else
|
|
QT_INSTALL_LIBEXECS_DIRNAME="libexec"
|
|
fi
|
|
|
|
if [ -z "$QT_INSTALL_LIBEXECS" ]; then #default
|
|
QT_INSTALL_LIBEXECS="$QT_INSTALL_ARCHDATA/$QT_INSTALL_LIBEXECS_DIRNAME" #fallback
|
|
fi
|
|
QT_INSTALL_LIBEXECS=`"$relpath/config.tests/unix/makeabs" "$QT_INSTALL_LIBEXECS"`
|
|
|
|
if [ -z "$QT_INSTALL_DOCS" ]; then #default
|
|
QT_INSTALL_DOCS="$QT_INSTALL_DATA/doc" #fallback
|
|
fi
|
|
QT_INSTALL_DOCS=`"$relpath/config.tests/unix/makeabs" "$QT_INSTALL_DOCS"`
|
|
|
|
if [ -z "$QT_INSTALL_PLUGINS" ]; then #default
|
|
QT_INSTALL_PLUGINS="$QT_INSTALL_ARCHDATA/plugins" #fallback
|
|
fi
|
|
QT_INSTALL_PLUGINS=`"$relpath/config.tests/unix/makeabs" "$QT_INSTALL_PLUGINS"`
|
|
|
|
if [ -z "$QT_INSTALL_IMPORTS" ]; then #default
|
|
QT_INSTALL_IMPORTS="$QT_INSTALL_ARCHDATA/imports" #fallback
|
|
fi
|
|
QT_INSTALL_IMPORTS=`"$relpath/config.tests/unix/makeabs" "$QT_INSTALL_IMPORTS"`
|
|
|
|
#qml
|
|
if [ -z "$QT_INSTALL_QML" ]; then #default
|
|
QT_INSTALL_QML="$QT_INSTALL_ARCHDATA/qml" #fallback
|
|
fi
|
|
QT_INSTALL_QML=`"$relpath/config.tests/unix/makeabs" "$QT_INSTALL_QML"`
|
|
|
|
if [ -z "$QT_INSTALL_TRANSLATIONS" ]; then #default
|
|
QT_INSTALL_TRANSLATIONS="$QT_INSTALL_DATA/translations" #fallback
|
|
fi
|
|
QT_INSTALL_TRANSLATIONS=`"$relpath/config.tests/unix/makeabs" "$QT_INSTALL_TRANSLATIONS"`
|
|
|
|
if [ -z "$QT_INSTALL_SETTINGS" ]; then #default
|
|
if [ "$XPLATFORM_MAC" = "yes" ]; then
|
|
QT_INSTALL_SETTINGS=/Library/Preferences/Qt
|
|
else
|
|
QT_INSTALL_SETTINGS=$QT_INSTALL_PREFIX/etc/xdg
|
|
fi
|
|
fi
|
|
QT_INSTALL_SETTINGS=`"$relpath/config.tests/unix/makeabs" "$QT_INSTALL_SETTINGS"`
|
|
|
|
if [ -z "$QT_INSTALL_EXAMPLES" ]; then #default
|
|
QT_INSTALL_EXAMPLES="$QT_INSTALL_PREFIX/examples" #fallback
|
|
fi
|
|
QT_INSTALL_EXAMPLES=`"$relpath/config.tests/unix/makeabs" "$QT_INSTALL_EXAMPLES"`
|
|
|
|
#tests
|
|
if [ -z "$QT_INSTALL_TESTS" ]; then #default
|
|
QT_INSTALL_TESTS="$QT_INSTALL_PREFIX/tests" #fallback
|
|
fi
|
|
QT_INSTALL_TESTS=`"$relpath/config.tests/unix/makeabs" "$QT_INSTALL_TESTS"`
|
|
|
|
#------- sysroot-external install paths --------
|
|
|
|
QT_SYSROOT_PREFIX=$QT_INSTALL_PREFIX
|
|
QT_SYSROOT_DOCS=$QT_INSTALL_DOCS
|
|
QT_SYSROOT_HEADERS=$QT_INSTALL_HEADERS
|
|
QT_SYSROOT_LIBS=$QT_INSTALL_LIBS
|
|
QT_SYSROOT_LIBEXECS=$QT_INSTALL_LIBEXECS
|
|
QT_SYSROOT_BINS=$QT_INSTALL_BINS
|
|
QT_SYSROOT_PLUGINS=$QT_INSTALL_PLUGINS
|
|
QT_SYSROOT_IMPORTS=$QT_INSTALL_IMPORTS
|
|
QT_SYSROOT_QML=$QT_INSTALL_QML
|
|
QT_SYSROOT_ARCHDATA=$QT_INSTALL_ARCHDATA
|
|
QT_SYSROOT_DATA=$QT_INSTALL_DATA
|
|
QT_SYSROOT_TRANSLATIONS=$QT_INSTALL_TRANSLATIONS
|
|
QT_SYSROOT_EXAMPLES=$QT_INSTALL_EXAMPLES
|
|
QT_SYSROOT_TESTS=$QT_INSTALL_TESTS
|
|
if [ -n "$QT_EXT_PREFIX" ]; then
|
|
QT_INSTALL_PREFIX=$QT_EXT_PREFIX
|
|
QT_INSTALL_DOCS=`substPrefix "$QT_INSTALL_DOCS"`
|
|
QT_INSTALL_HEADERS=`substPrefix "$QT_INSTALL_HEADERS"`
|
|
QT_INSTALL_LIBS=`substPrefix "$QT_INSTALL_LIBS"`
|
|
QT_INSTALL_LIBEXECS=`substPrefix "$QT_INSTALL_LIBEXECS"`
|
|
QT_INSTALL_BINS=`substPrefix "$QT_INSTALL_BINS"`
|
|
QT_INSTALL_PLUGINS=`substPrefix "$QT_INSTALL_PLUGINS"`
|
|
QT_INSTALL_IMPORTS=`substPrefix "$QT_INSTALL_IMPORTS"`
|
|
QT_INSTALL_QML=`substPrefix "$QT_INSTALL_QML"`
|
|
QT_INSTALL_ARCHDATA=`substPrefix "$QT_INSTALL_ARCHDATA"`
|
|
QT_INSTALL_DATA=`substPrefix "$QT_INSTALL_DATA"`
|
|
QT_INSTALL_TRANSLATIONS=`substPrefix "$QT_INSTALL_TRANSLATIONS"`
|
|
QT_INSTALL_EXAMPLES=`substPrefix "$QT_INSTALL_EXAMPLES"`
|
|
QT_INSTALL_TESTS=`substPrefix "$QT_INSTALL_TESTS"`
|
|
fi
|
|
|
|
#------- host paths --------
|
|
|
|
if [ -z "$QT_HOST_PREFIX" ]; then
|
|
QT_HOST_PREFIX=$QT_INSTALL_PREFIX
|
|
haveHpx=false
|
|
else
|
|
QT_HOST_PREFIX=`"$relpath/config.tests/unix/makeabs" "$QT_HOST_PREFIX"`
|
|
haveHpx=true
|
|
fi
|
|
|
|
if [ -z "$QT_HOST_BINS" ]; then #default
|
|
if $haveHpx; then
|
|
QT_HOST_BINS="$QT_HOST_PREFIX/bin" #fallback
|
|
else
|
|
QT_HOST_BINS="$QT_INSTALL_BINS"
|
|
fi
|
|
fi
|
|
QT_HOST_BINS=`"$relpath/config.tests/unix/makeabs" "$QT_HOST_BINS"`
|
|
|
|
if [ -z "$QT_HOST_LIBS" ]; then #default
|
|
if $haveHpx; then
|
|
QT_HOST_LIBS="$QT_HOST_PREFIX/lib" #fallback
|
|
else
|
|
QT_HOST_LIBS="$QT_INSTALL_LIBS"
|
|
fi
|
|
fi
|
|
QT_HOST_LIBS=`"$relpath/config.tests/unix/makeabs" "$QT_HOST_LIBS"`
|
|
|
|
if [ -z "$QT_HOST_DATA" ]; then #default
|
|
if $haveHpx; then
|
|
QT_HOST_DATA="$QT_HOST_PREFIX"
|
|
else
|
|
QT_HOST_DATA="$QT_INSTALL_ARCHDATA"
|
|
fi
|
|
else
|
|
QT_HOST_DATA=`"$relpath/config.tests/unix/makeabs" "$QT_HOST_DATA"`
|
|
fi
|
|
|
|
if [ "$CFG_COMPILE_EXAMPLES" = "yes" ]; then
|
|
QMAKE_CONFIG="$QMAKE_CONFIG compile_examples"
|
|
fi
|
|
|
|
#-------------------------------------------------------------------------------
|
|
# generate qconfig.cpp
|
|
#-------------------------------------------------------------------------------
|
|
[ -d "$outpath/src/corelib/global" ] || mkdir -p "$outpath/src/corelib/global"
|
|
|
|
shortxspec=`echo $XQMAKESPEC | sed "s,^${relpath}/mkspecs/,,"`
|
|
shortspec=`echo $QMAKESPEC | sed "s,^${relpath}/mkspecs/,,"`
|
|
|
|
if [ -z "$QT_EXT_PREFIX" ]; then
|
|
QMAKE_SYSROOTIFY=y
|
|
else
|
|
QMAKE_SYSROOTIFY=n
|
|
fi
|
|
|
|
cat > "$outpath/src/corelib/global/qconfig.cpp.new" <<EOF
|
|
/* License Info */
|
|
static const char qt_configure_licensee_str [256 + 12] = "qt_lcnsuser=$Licensee";
|
|
static const char qt_configure_licensed_products_str [256 + 12] = "qt_lcnsprod=$Edition";
|
|
|
|
/* Installation date */
|
|
static const char qt_configure_installation [12+11] = "qt_instdate=`date +%Y-%m-%d`";
|
|
|
|
/* Installation Info */
|
|
static const char qt_configure_prefix_path_strs[][256 + 12] = {
|
|
#ifndef QT_BUILD_QMAKE
|
|
"qt_prfxpath=$QT_SYSROOT_PREFIX",
|
|
"qt_docspath=$QT_SYSROOT_DOCS",
|
|
"qt_hdrspath=$QT_SYSROOT_HEADERS",
|
|
"qt_libspath=$QT_SYSROOT_LIBS",
|
|
"qt_lbexpath=$QT_SYSROOT_LIBEXECS",
|
|
"qt_binspath=$QT_SYSROOT_BINS",
|
|
"qt_plugpath=$QT_SYSROOT_PLUGINS",
|
|
"qt_impspath=$QT_SYSROOT_IMPORTS",
|
|
"qt_qml2path=$QT_SYSROOT_QML",
|
|
"qt_adatpath=$QT_SYSROOT_ARCHDATA",
|
|
"qt_datapath=$QT_SYSROOT_DATA",
|
|
"qt_trnspath=$QT_SYSROOT_TRANSLATIONS",
|
|
"qt_xmplpath=$QT_SYSROOT_EXAMPLES",
|
|
"qt_tstspath=$QT_SYSROOT_TESTS",
|
|
#else
|
|
"qt_prfxpath=$QT_INSTALL_PREFIX",
|
|
"qt_docspath=$QT_INSTALL_DOCS",
|
|
"qt_hdrspath=$QT_INSTALL_HEADERS",
|
|
"qt_libspath=$QT_INSTALL_LIBS",
|
|
"qt_lbexpath=$QT_INSTALL_LIBEXECS",
|
|
"qt_binspath=$QT_INSTALL_BINS",
|
|
"qt_plugpath=$QT_INSTALL_PLUGINS",
|
|
"qt_impspath=$QT_INSTALL_IMPORTS",
|
|
"qt_qml2path=$QT_INSTALL_QML",
|
|
"qt_adatpath=$QT_INSTALL_ARCHDATA",
|
|
"qt_datapath=$QT_INSTALL_DATA",
|
|
"qt_trnspath=$QT_INSTALL_TRANSLATIONS",
|
|
"qt_xmplpath=$QT_INSTALL_EXAMPLES",
|
|
"qt_tstspath=$QT_INSTALL_TESTS",
|
|
"qt_ssrtpath=$CFG_SYSROOT",
|
|
"qt_hpfxpath=$QT_HOST_PREFIX",
|
|
"qt_hbinpath=$QT_HOST_BINS",
|
|
"qt_hlibpath=$QT_HOST_LIBS",
|
|
"qt_hdatpath=$QT_HOST_DATA",
|
|
"qt_targspec=$shortxspec",
|
|
"qt_hostspec=$shortspec",
|
|
#endif
|
|
};
|
|
static const char qt_configure_settings_path_str[256 + 12] = "qt_stngpath=$QT_INSTALL_SETTINGS";
|
|
|
|
#ifdef QT_BUILD_QMAKE
|
|
static const char qt_sysrootify_prefix[] = "qt_ssrtfpfx=$QMAKE_SYSROOTIFY";
|
|
#endif
|
|
EOF
|
|
|
|
cat >> "$outpath/src/corelib/global/qconfig.cpp.new" <<EOF
|
|
|
|
/* strlen( "qt_lcnsxxxx" ) == 12 */
|
|
#define QT_CONFIGURE_LICENSEE qt_configure_licensee_str + 12;
|
|
#define QT_CONFIGURE_LICENSED_PRODUCTS qt_configure_licensed_products_str + 12;
|
|
|
|
#define QT_CONFIGURE_SETTINGS_PATH qt_configure_settings_path_str + 12;
|
|
EOF
|
|
|
|
# avoid unecessary rebuilds by copying only if qconfig.cpp has changed
|
|
if cmp -s "$outpath/src/corelib/global/qconfig.cpp" "$outpath/src/corelib/global/qconfig.cpp.new"; then
|
|
rm -f "$outpath/src/corelib/global/qconfig.cpp.new"
|
|
else
|
|
[ -f "$outpath/src/corelib/global/qconfig.cpp" ] && chmod +w "$outpath/src/corelib/global/qconfig.cpp"
|
|
mv "$outpath/src/corelib/global/qconfig.cpp.new" "$outpath/src/corelib/global/qconfig.cpp"
|
|
chmod -w "$outpath/src/corelib/global/qconfig.cpp"
|
|
fi
|
|
|
|
# -----------------------------------------------------------------------------
|
|
if [ "$LicenseType" = "Evaluation" ]; then
|
|
EVALKEY=qt_qevalkey=$LicenseKeyExt
|
|
elif echo "$DEFINES" | grep QT_EVAL >/dev/null 2>&1; then
|
|
EVALKEY=qt_qevalkey=
|
|
fi
|
|
|
|
if [ -n "$EVALKEY" ]; then
|
|
rm -f "$outpath/src/corelib/global/qconfig_eval.cpp"
|
|
cat > "$outpath/src/corelib/global/qconfig_eval.cpp" <<EOF
|
|
/* Evaluation license key */
|
|
static const volatile char qt_eval_key_data [512 + 12] = "$EVALKEY";
|
|
EOF
|
|
chmod -w "$outpath/src/corelib/global/qconfig_eval.cpp"
|
|
fi
|
|
|
|
|
|
# -----------------------------------------------------------------------------
|
|
# build qmake
|
|
# -----------------------------------------------------------------------------
|
|
|
|
# symlink includes
|
|
if [ -e "$relpath/.git" ]; then
|
|
if [ -z "$PERL" ]; then
|
|
echo
|
|
echo "You need perl in your PATH to make a build from GIT."
|
|
echo "Cannot proceed."
|
|
exit 1
|
|
fi
|
|
|
|
"$relpath/bin/syncqt.pl" -minimal -module QtCore "$relpath" || exit 1
|
|
fi
|
|
|
|
# $1: input variable name (awk regexp)
|
|
# $2: optional output variable name
|
|
# $3: optional value transformation (sed command)
|
|
# relies on $QMAKESPEC, $COMPILER_CONF and $mkfile being set correctly, as the latter
|
|
# is where the resulting variable is written to
|
|
setBootstrapVariable()
|
|
{
|
|
getQMakeConf "$1" | echo ${2-$1} = `if [ -n "$3" ]; then sed "$3"; else cat; fi` >> "$mkfile"
|
|
}
|
|
|
|
# build qmake
|
|
if true; then ###[ '!' -f "$outpath/bin/qmake" ];
|
|
echo "Creating qmake..."
|
|
|
|
mkdir -p "$outpath/qmake" || exit
|
|
# fix makefiles
|
|
for mkfile in GNUmakefile Makefile; do
|
|
EXTRA_LFLAGS=
|
|
EXTRA_CFLAGS=
|
|
in_mkfile="${mkfile}.in"
|
|
if [ "$mkfile" = "Makefile" ]; then
|
|
# if which qmake >/dev/null 2>&1 && [ -f qmake/qmake.pro ]; then
|
|
# (cd qmake && qmake) >/dev/null 2>&1 && continue
|
|
# fi
|
|
in_mkfile="${mkfile}.unix"
|
|
fi
|
|
in_mkfile="$relpath/qmake/$in_mkfile"
|
|
mkfile="$outpath/qmake/$mkfile"
|
|
if [ -f "$mkfile" ]; then
|
|
[ "$CFG_DEV" = "yes" ] && "$WHICH" chflags >/dev/null 2>&1 && chflags nouchg "$mkfile"
|
|
rm -f "$mkfile"
|
|
fi
|
|
[ -f "$in_mkfile" ] || continue
|
|
|
|
echo "########################################################################" > "$mkfile"
|
|
echo "## This file was autogenerated by configure, all changes will be lost ##" >> "$mkfile"
|
|
echo "########################################################################" >> "$mkfile"
|
|
EXTRA_OBJS=
|
|
EXTRA_SRCS=
|
|
EXTRA_CFLAGS="\$(QMAKE_CFLAGS)"
|
|
EXTRA_CXXFLAGS="\$(QMAKE_CXXFLAGS)"
|
|
EXTRA_LFLAGS="\$(QMAKE_LFLAGS)"
|
|
|
|
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_CXXFLAGS
|
|
setBootstrapVariable QMAKE_LFLAGS
|
|
|
|
if [ "$CFG_RELEASE_QMAKE" = "yes" ]; then
|
|
setBootstrapVariable QMAKE_CFLAGS_RELEASE
|
|
setBootstrapVariable QMAKE_CXXFLAGS_RELEASE
|
|
EXTRA_CFLAGS="$EXTRA_CFLAGS \$(QMAKE_CFLAGS_RELEASE)"
|
|
EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS \$(QMAKE_CXXFLAGS_RELEASE)"
|
|
elif [ "$CFG_DEBUG" = "yes" ]; then
|
|
setBootstrapVariable QMAKE_CFLAGS_DEBUG
|
|
setBootstrapVariable QMAKE_CXXFLAGS_DEBUG
|
|
EXTRA_CFLAGS="$EXTRA_CFLAGS \$(QMAKE_CFLAGS_DEBUG)"
|
|
EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS \$(QMAKE_CXXFLAGS_DEBUG)"
|
|
fi
|
|
|
|
if [ -n "$RPATH_FLAGS" ] && [ -n "`getQMakeConf 'QMAKE_(LFLAGS_)?RPATH'`" ]; then
|
|
setBootstrapVariable "QMAKE_(LFLAGS_)?RPATH" QMAKE_LFLAGS_RPATH
|
|
for rpath in $RPATH_FLAGS; do
|
|
EXTRA_LFLAGS="\$(QMAKE_LFLAGS_RPATH)\"$rpath\" $EXTRA_LFLAGS"
|
|
done
|
|
fi
|
|
if [ "$BUILD_ON_MSYS" = "yes" ]; then
|
|
EXTRA_CFLAGS="-DUNICODE"
|
|
EXTRA_CXXFLAGS="-DUNICODE"
|
|
EXTRA_OBJS="qfilesystemengine_win.o \
|
|
qfilesystemiterator_win.o \
|
|
qfsfileengine_win.o \
|
|
qlocale_win.o \
|
|
qsettings_win.o \
|
|
qsystemlibrary.o \
|
|
registry.o"
|
|
EXTRA_SRCS="\"\$(SOURCE_PATH)/src/corelib/corelib/io/qfilesystemengine_win.cpp\" \
|
|
\"\$(SOURCE_PATH)/src/corelib/io/qfilesystemiterator_win.cpp\" \
|
|
\"\$(SOURCE_PATH)/src/corelib/io/qfsfileengine_win.cpp\" \
|
|
\"\$(SOURCE_PATH)/src/corelib/io/qsettings_win.cpp\" \
|
|
\"\$(SOURCE_PATH)/src/corelib/tools/qlocale_win.cpp\" \
|
|
\"\$(SOURCE_PATH)/src/corelib/plugin/qsystemlibrary.cpp\" \
|
|
\"\$(SOURCE_PATH)/tools/shared/windows/registry.cpp\""
|
|
EXTRA_LFLAGS="-static -s -lole32 -luuid -ladvapi32 -lkernel32"
|
|
EXEEXT=".exe"
|
|
else
|
|
EXTRA_OBJS="qfilesystemengine_unix.o \
|
|
qfilesystemiterator_unix.o \
|
|
qfsfileengine_unix.o \
|
|
qlocale_unix.o"
|
|
EXTRA_SRCS="\"\$(SOURCE_PATH)/src/corelib/io/qfilesystemengine_unix.cpp\" \
|
|
\"\$(SOURCE_PATH)/src/corelib/io/qfilesystemiterator_unix.cpp\" \
|
|
\"\$(SOURCE_PATH)/src/corelib/io/qfsfileengine_unix.cpp\" \
|
|
\"\$(SOURCE_PATH)/src/corelib/tools/qlocal_unix.cpp\""
|
|
EXEEXT=
|
|
fi
|
|
if [ "$BUILD_ON_MAC" = "yes" ]; then
|
|
echo "CARBON_LFLAGS =-framework ApplicationServices" >>"$mkfile"
|
|
echo "CARBON_CFLAGS =-fconstant-cfstrings" >>"$mkfile"
|
|
EXTRA_LFLAGS="$EXTRA_LFLAGS \$(CARBON_LFLAGS)"
|
|
EXTRA_CFLAGS="$EXTRA_CFLAGS \$(CARBON_CFLAGS)"
|
|
EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS \$(CARBON_CFLAGS)"
|
|
EXTRA_OBJS="$EXTRA_OBJS \
|
|
qsettings_mac.o \
|
|
qcore_mac.o"
|
|
EXTRA_SRCS="$EXTRA_SRCS \
|
|
\"\$(SOURCE_PATH)/src/corelib/io/qsettings_mac.cpp\" \
|
|
\"\$(SOURCE_PATH)/src/corelib/kernel/qcore_mac.cpp\""
|
|
fi
|
|
if [ '!' -z "$D_FLAGS" ]; then
|
|
EXTRA_CFLAGS="$EXTRA_CFLAGS $D_FLAGS"
|
|
fi
|
|
echo >>"$mkfile"
|
|
adjrelpath=`echo "$relpath" | sed 's/ /\\\\\\\\ /g'`
|
|
adjoutpath=`echo "$outpath" | sed 's/ /\\\\\\\\ /g'`
|
|
adjqmakespec=`echo "$QMAKESPEC" | sed 's/ /\\\\\\\\ /g'`
|
|
|
|
echo "BUILD_PATH = $adjoutpath" >> "$mkfile"
|
|
echo "SOURCE_PATH = $adjrelpath" >> "$mkfile"
|
|
if [ -e "$relpath/.git" ]; then
|
|
echo 'INC_PATH = $(BUILD_PATH)/include' >> "$mkfile"
|
|
else
|
|
echo 'INC_PATH = $(SOURCE_PATH)/include' >> "$mkfile"
|
|
fi
|
|
echo "QMAKESPEC = $adjqmakespec" >> "$mkfile"
|
|
echo "QT_VERSION = $QT_VERSION" >> "$mkfile"
|
|
echo "EXTRA_CFLAGS = $EXTRA_CFLAGS" >> "$mkfile"
|
|
echo "EXTRA_CXXFLAGS = $EXTRA_CXXFLAGS" >> "$mkfile"
|
|
echo "QTOBJS =" $EXTRA_OBJS >> "$mkfile"
|
|
echo "QTSRCS =" $EXTRA_SRCS >> "$mkfile"
|
|
echo "LFLAGS = $EXTRA_LFLAGS" >> "$mkfile"
|
|
echo "EXEEXT = $EXEEXT" >> "$mkfile"
|
|
echo "RM_F = rm -f" >> "$mkfile"
|
|
echo "RM_RF = rm -rf" >> "$mkfile"
|
|
if [ $QT_EDITION = "QT_EDITION_OPENSOURCE" ]; then
|
|
echo "EXTRA_CPPFLAGS = -DQMAKE_OPENSOURCE_EDITION" >> "$mkfile"
|
|
fi
|
|
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
|
|
done
|
|
|
|
(cd "$outpath/qmake"; "$MAKE") || exit 2
|
|
fi # Build qmake
|
|
|
|
echo "Running configuration tests..."
|
|
|
|
#-------------------------------------------------------------------------------
|
|
# create a qt.conf for the Qt build tree itself
|
|
#-------------------------------------------------------------------------------
|
|
|
|
QTCONFFILE="$outpath/bin/qt.conf"
|
|
cat > "$QTCONFFILE" <<EOF
|
|
[EffectivePaths]
|
|
Prefix=..
|
|
EOF
|
|
if [ x"$relpath" != x"$outpath" ]; then
|
|
cat >> "$QTCONFFILE" <<EOF
|
|
[EffectiveSourcePaths]
|
|
Prefix=$relpath
|
|
EOF
|
|
fi
|
|
|
|
#-------------------------------------------------------------------------------
|
|
# write out device config before we run the test.
|
|
#-------------------------------------------------------------------------------
|
|
DEVICE_VARS_OUTFILE="$outpath/mkspecs/qdevice.pri"
|
|
if cmp -s "$DEVICE_VARS_FILE" "$DEVICE_VARS_OUTFILE"; then
|
|
rm -f "$DEVICE_VARS_FILE"
|
|
else
|
|
mv -f $DEVICE_VARS_FILE "$DEVICE_VARS_OUTFILE"
|
|
DEVICE_VARS_FILE="$DEVICE_VARS_OUTFILE"
|
|
fi
|
|
|
|
#-------------------------------------------------------------------------------
|
|
# Verify makespec
|
|
#-------------------------------------------------------------------------------
|
|
QMAKE_OUTPUT=`$outpath/bin/qmake -E -nocache -spec "$XQMAKESPEC" "QT=" $DEV_NULL 2>&1`
|
|
if [ $? != "0" ]; then
|
|
echo "Failed to process makespec for platform '$XPLATFORM'"
|
|
if [ "$OPT_VERBOSE" = "yes" ]; then
|
|
echo "$QMAKE_OUTPUT"
|
|
else
|
|
echo "Turn on verbose messaging (-v) to see the final report."
|
|
fi
|
|
exit 101
|
|
fi
|
|
|
|
#-------------------------------------------------------------------------------
|
|
# Detect pkg-config
|
|
#-------------------------------------------------------------------------------
|
|
if [ -z "$PKG_CONFIG" ]; then
|
|
# See if PKG_CONFIG is set in the mkspec:
|
|
PKG_CONFIG="`"$outpath/bin/qmake" -E -nocache -spec "$XQMAKESPEC" "CONFIG=" $DEV_NULL 2>&1 | sed -n -e 's,^PKG_CONFIG = \(.*\),\1,p'`"
|
|
fi
|
|
if [ -z "$PKG_CONFIG" ]; then
|
|
PKG_CONFIG=`"$WHICH" pkg-config 2>/dev/null`
|
|
fi
|
|
|
|
if [ "$CFG_PKGCONFIG" = "no" ]; then
|
|
PKG_CONFIG=
|
|
elif [ "$CFG_PKGCONFIG" = "force" ]; then
|
|
echo >&2 ""
|
|
echo >&2 "You have asked to use pkg-config. Please make sure you have"
|
|
echo >&2 "a correctly setup pkg-config environment!"
|
|
echo >&2 ""
|
|
elif [ -n "$PKG_CONFIG" ]; then
|
|
# found a pkg-config
|
|
if [ "$QT_CROSS_COMPILE" = "yes" ]; then
|
|
# when xcompiling, check environment to see if it's actually usable
|
|
if [ -z "$PKG_CONFIG_LIBDIR" ]; then
|
|
if [ -n "$CFG_SYSROOT" ] && [ -d "$CFG_SYSROOT/usr/lib/pkgconfig" ]; then
|
|
PKG_CONFIG_LIBDIR=$CFG_SYSROOT/usr/lib/pkgconfig:$CFG_SYSROOT/usr/share/pkgconfig
|
|
if [ -n "$GCC_MACHINE_DUMP" ]; then
|
|
PKG_CONFIG_LIBDIR=$PKG_CONFIG_LIBDIR:$CFG_SYSROOT/usr/lib/$GCC_MACHINE_DUMP/pkgconfig
|
|
fi
|
|
export PKG_CONFIG_LIBDIR
|
|
echo >&2 "Note: PKG_CONFIG_LIBDIR automatically set to $PKG_CONFIG_LIBDIR"
|
|
elif [ "$CFG_PKGCONFIG" = "yes" ]; then
|
|
echo >&2 "Error: PKG_CONFIG_LIBDIR has not been set. This could mean"
|
|
echo >&2 "the host's .pc files will be used (even if you set PKG_CONFIG_PATH)."
|
|
echo >&2 "Set this variable to the directory that contains target .pc files"
|
|
echo >&2 "for pkg-config to function correctly when cross-compiling or"
|
|
echo >&2 "use -force-pkg-config to override this test."
|
|
exit 101
|
|
else
|
|
PKG_CONFIG=
|
|
echo >&2 "Warning: Disabling pkg-config since PKG_CONFIG_LIBDIR is not set."
|
|
fi
|
|
fi
|
|
if [ -z "$PKG_CONFIG_SYSROOT_DIR" ]; then
|
|
if [ -n "$CFG_SYSROOT" ]; then
|
|
PKG_CONFIG_SYSROOT_DIR=$CFG_SYSROOT
|
|
export PKG_CONFIG_SYSROOT_DIR
|
|
echo >&2 "Note: PKG_CONFIG_SYSROOT_DIR automatically set to $PKG_CONFIG_SYSROOT_DIR"
|
|
elif [ "$CFG_PKGCONFIG" = "yes" ]; then
|
|
echo >&2 "Error: PKG_CONFIG_SYSROOT_DIR has not been set. Set this variable"
|
|
echo >&2 "to your sysroot for pkg-config to function correctly when cross-compiling"
|
|
echo >&2 "or use -force-pkg-config to override this test."
|
|
exit 101
|
|
else
|
|
PKG_CONFIG=
|
|
echo >&2 "Warning: Disabling pkg-config since PKG_CONFIG_SYSROOT_DIR is not set."
|
|
fi
|
|
fi
|
|
fi
|
|
elif [ "$CFG_PKGCONFIG" = "yes" ]; then
|
|
echo >&2 "Could not detect pkg-config from mkspec or PATH."
|
|
exit 101
|
|
fi
|
|
|
|
if [ -z "$PKG_CONFIG" ]; then
|
|
QT_CONFIG="$QT_CONFIG no-pkg-config"
|
|
fi
|
|
|
|
#-------------------------------------------------------------------------------
|
|
# tests that need qmake
|
|
#-------------------------------------------------------------------------------
|
|
|
|
# parameters: path, name, extra args
|
|
compileTest()
|
|
{
|
|
path=config.tests/$1
|
|
name=$2
|
|
shift 2
|
|
"$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" "$path" "$name" $I_FLAGS $D_FLAGS $L_FLAGS "$@"
|
|
}
|
|
|
|
#-------------------------------------------------------------------------------
|
|
# determine the target and host architectures
|
|
#-------------------------------------------------------------------------------
|
|
|
|
# Use config.tests/arch/arch.pro to have the compiler tell us what the target architecture is
|
|
OUTFILE=$outpath/arch.result
|
|
"$unixtests/arch.test" "$XQMAKESPEC" $OPT_VERBOSE "$relpath" "$outpath" "$OUTFILE" "target"
|
|
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"
|
|
if [ $? -eq 0 ]; then
|
|
eval `cat "$OUTFILE"`
|
|
else
|
|
echo
|
|
echo "Could not determine the host architecture!"
|
|
echo "Turn on verbose messaging (-v) to see the final report."
|
|
fi
|
|
rm -f "$OUTFILE" 2>/dev/null
|
|
[ -z "$CFG_HOST_ARCH" ] && CFG_HOST_ARCH="unknown"
|
|
else
|
|
# not cross compiling, host == target
|
|
CFG_HOST_ARCH="$CFG_ARCH"
|
|
CFG_HOST_CPUFEATURES="$CFG_CPUFEATURES"
|
|
fi
|
|
unset OUTFILE
|
|
|
|
if [ "$OPT_VERBOSE" = "yes" ]; then
|
|
echo "System architecture: '$CFG_ARCH'"
|
|
echo "Host architecture: '$CFG_HOST_ARCH'"
|
|
fi
|
|
|
|
#-------------------------------------------------------------------------------
|
|
# functionality tests
|
|
#-------------------------------------------------------------------------------
|
|
|
|
# Detect C++11 support
|
|
if [ "$CFG_CXX11" != "no" ]; then
|
|
# Configure detects compiler features based on cross compiler, so we need
|
|
# to explicitly disable C++11 on Mac to avoid breaking builds where the
|
|
# host compiler does not support it.
|
|
if [ "$BUILD_ON_MAC" = "yes" ] && [ "$XPLATFORM_ANDROID" = "yes" ]; then
|
|
CFG_CXX11="no"
|
|
elif compileTest common/c++11 "C++11"; then
|
|
CFG_CXX11="yes"
|
|
elif [ "$CFG_CXX11" != "auto" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
|
|
echo "C++11 support cannot be enabled due to functionality tests!"
|
|
echo " Turn on verbose messaging (-v) to $0 to see the final report."
|
|
echo " If you believe this message is in error you may use the continue"
|
|
echo " switch (-continue) to $0 to continue."
|
|
exit 101
|
|
else
|
|
CFG_CXX11="no"
|
|
fi
|
|
fi
|
|
|
|
# detect availability of float math.h functions
|
|
if compileTest unix/floatmath "floatmath"; then
|
|
CFG_USE_FLOATMATH=yes
|
|
else
|
|
CFG_USE_FLOATMATH=no
|
|
fi
|
|
|
|
# detect sse2 support
|
|
if [ "${CFG_SSE2}" = "auto" ]; then
|
|
if compileTest common/sse2 "sse2"; then
|
|
CFG_SSE2=yes
|
|
else
|
|
CFG_SSE2=no
|
|
fi
|
|
fi
|
|
|
|
# detect sse3 support
|
|
if [ "${CFG_SSE3}" = "auto" ]; then
|
|
if compileTest common/sse3 "sse3"; then
|
|
CFG_SSE3=yes
|
|
else
|
|
CFG_SSE3=no
|
|
fi
|
|
fi
|
|
|
|
# detect ssse3 support
|
|
if [ "${CFG_SSSE3}" = "auto" ]; then
|
|
if compileTest common/ssse3 "ssse3"; then
|
|
CFG_SSSE3=yes
|
|
else
|
|
CFG_SSSE3=no
|
|
fi
|
|
fi
|
|
|
|
# detect sse4.1 support
|
|
if [ "${CFG_SSE4_1}" = "auto" ]; then
|
|
if compileTest common/sse4_1 "sse4_1"; then
|
|
CFG_SSE4_1=yes
|
|
else
|
|
CFG_SSE4_1=no
|
|
fi
|
|
fi
|
|
|
|
# detect sse4.2 support
|
|
if [ "${CFG_SSE4_2}" = "auto" ]; then
|
|
if compileTest common/sse4_2 "sse4_2"; then
|
|
CFG_SSE4_2=yes
|
|
else
|
|
CFG_SSE4_2=no
|
|
fi
|
|
fi
|
|
|
|
# detect avx support
|
|
if [ "${CFG_AVX}" = "auto" ]; then
|
|
if compileTest common/avx "avx"; then
|
|
case "$XQMAKESPEC" in
|
|
*g++*|*-clang*)
|
|
# Some clang versions produce internal compiler errors compiling Qt AVX code
|
|
case `$TEST_COMPILER --version` in
|
|
Apple\ clang\ version\ [23]*)
|
|
CFG_AVX=no
|
|
if [ "$OPT_VERBOSE" = "yes" ]; then
|
|
echo 'AVX support disabled for blacklisted clang compiler'
|
|
fi
|
|
;;
|
|
*)
|
|
CFG_AVX=yes
|
|
;;
|
|
esac
|
|
;;
|
|
*)
|
|
CFG_AVX=yes
|
|
;;
|
|
esac
|
|
else
|
|
CFG_AVX=no
|
|
fi
|
|
fi
|
|
|
|
# detect avx2 support
|
|
if [ "${CFG_AVX}" = "no" ]; then
|
|
CFG_AVX2=no
|
|
fi
|
|
if [ "${CFG_AVX2}" = "auto" ]; then
|
|
if compileTest common/avx2 "avx2"; then
|
|
CFG_AVX2=yes
|
|
else
|
|
CFG_AVX2=no
|
|
fi
|
|
fi
|
|
|
|
# check iWMMXt support
|
|
if [ "$CFG_IWMMXT" = "yes" ]; then
|
|
compileTest unix/iwmmxt "iwmmxt"
|
|
if [ $? != "0" ]; then
|
|
echo "The iWMMXt functionality test failed!"
|
|
echo " Please make sure your compiler supports iWMMXt intrinsics!"
|
|
exit 1
|
|
fi
|
|
fi
|
|
|
|
# detect neon support
|
|
if [ "$CFG_ARCH" = "arm" ] && [ "${CFG_NEON}" = "auto" ]; then
|
|
if compileTest unix/neon "neon"; then
|
|
CFG_NEON=yes
|
|
else
|
|
CFG_NEON=no
|
|
fi
|
|
elif [ "$CFG_ARCH" != "arm" ]; then
|
|
CFG_NEON=no
|
|
fi
|
|
|
|
# detect mips_dsp support
|
|
if [ "$CFG_ARCH" = "mips" ] && [ "${CFG_MIPS_DSP}" = "auto" ]; then
|
|
if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/mips_dsp "mips_dsp" $L_FLAGS $I_FLAGS $D_FLAGS $l_FLAGS; then
|
|
CFG_MIPS_DSP=yes
|
|
else
|
|
CFG_MIPS_DSP=no
|
|
fi
|
|
elif [ "$CFG_ARCH" != "mips" ]; then
|
|
CFG_MIPS_DSP=no
|
|
fi
|
|
|
|
# detect mips_dspr2 support
|
|
if [ "$CFG_ARCH" = "mips" ] && [ "${CFG_MIPS_DSPR2}" = "auto" ]; then
|
|
if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/mips_dspr2 "mips_dspr2" $L_FLAGS $I_FLAGS $D_FLAGS $l_FLAGS; then
|
|
CFG_MIPS_DSPR2=yes
|
|
else
|
|
CFG_MIPS_DSPR2=no
|
|
fi
|
|
elif [ "$CFG_ARCH" != "mips" ]; then
|
|
CFG_MIPS_DSPR2=no
|
|
fi
|
|
|
|
[ "$XPLATFORM_MINGW" = "yes" ] && QMakeVar add styles "windowsxp windowsvista"
|
|
[ "$XPLATFORM_ANDROID" = "yes" ] && QMakeVar add styles "android"
|
|
|
|
# detect zlib
|
|
if [ "$CFG_ZLIB" = "no" ]; then
|
|
# Note: Qt no longer support builds without zlib
|
|
# So we force a "no" to be "auto" here.
|
|
# If you REALLY really need no zlib support, you can still disable
|
|
# it by doing the following:
|
|
# add "no-zlib" to mkspecs/qconfig.pri
|
|
# #define QT_NO_COMPRESS (probably by adding to src/corelib/global/qconfig.h)
|
|
#
|
|
# There's no guarantee that Qt will build under those conditions
|
|
|
|
CFG_ZLIB=auto
|
|
ZLIB_FORCED=yes
|
|
fi
|
|
|
|
if [ "$XPLATFORM_QNX" = "yes" ]; then
|
|
if [ "$CFG_SLOG2" != "no" ]; then
|
|
if compileTest unix/slog2 "slog2"; then
|
|
CFG_SLOG2=yes
|
|
QMAKE_CONFIG="$QMAKE_CONFIG slog2"
|
|
else
|
|
CFG_SLOG2=no
|
|
fi
|
|
fi
|
|
|
|
if [ "$CFG_PPS" != "no" ]; then
|
|
if compileTest unix/pps "pps"; then
|
|
CFG_PPS=yes
|
|
QMAKE_CONFIG="$QMAKE_CONFIG qqnx_pps"
|
|
else
|
|
CFG_PPS=no
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
if [ "$CFG_ZLIB" = "auto" ]; then
|
|
if compileTest unix/zlib "zlib"; then
|
|
CFG_ZLIB=system
|
|
else
|
|
CFG_ZLIB=yes
|
|
fi
|
|
fi
|
|
|
|
if [ "$CFG_LARGEFILE" = "auto" ]; then
|
|
#Large files should be enabled for all Linux systems
|
|
CFG_LARGEFILE=yes
|
|
fi
|
|
|
|
if [ "$CFG_GUI" = "no" ]; then
|
|
QPA_PLATFORM_GUARD=no
|
|
fi
|
|
|
|
# detect how jpeg should be built
|
|
if [ "$CFG_JPEG" = "auto" ]; then
|
|
if [ "$CFG_SHARED" = "yes" ]; then
|
|
CFG_JPEG=plugin
|
|
else
|
|
CFG_JPEG=yes
|
|
fi
|
|
fi
|
|
# detect jpeg
|
|
if [ "$CFG_LIBJPEG" = "auto" ]; then
|
|
if compileTest unix/libjpeg "libjpeg"; then
|
|
CFG_LIBJPEG=system
|
|
else
|
|
CFG_LIBJPEG=qt
|
|
fi
|
|
fi
|
|
|
|
# detect how gif should be built
|
|
if [ "$CFG_GIF" = "auto" ]; then
|
|
if [ "$CFG_SHARED" = "yes" ]; then
|
|
CFG_GIF=plugin
|
|
else
|
|
CFG_GIF=yes
|
|
fi
|
|
fi
|
|
|
|
# detect png
|
|
if [ "$CFG_LIBPNG" = "auto" ]; then
|
|
if compileTest unix/libpng "libpng"; then
|
|
CFG_LIBPNG=system
|
|
else
|
|
CFG_LIBPNG=qt
|
|
fi
|
|
fi
|
|
|
|
if [ "$CFG_EGLFS" = "yes" ]; then
|
|
if [ "$CFG_EGL" = "no" ]; then
|
|
echo "The EGLFS plugin requires EGL support and cannot be built"
|
|
exit 101
|
|
fi
|
|
CFG_EGL=yes
|
|
fi
|
|
|
|
if [ "$CFG_KMS" = "yes" ]; then
|
|
if [ "$CFG_EGL" = "no" ]; then
|
|
echo "The KMS plugin requires EGL support and cannot be built"
|
|
exit 101
|
|
fi
|
|
fi
|
|
|
|
# auto-detect SQL-modules support
|
|
for _SQLDR in $CFG_SQL_AVAILABLE; do
|
|
case $_SQLDR in
|
|
mysql)
|
|
if [ "$CFG_SQL_mysql" != "no" ]; then
|
|
[ -z "$CFG_MYSQL_CONFIG" ] && CFG_MYSQL_CONFIG=`"$WHICH" mysql_config`
|
|
if [ -x "$CFG_MYSQL_CONFIG" ]; then
|
|
QT_CFLAGS_MYSQL=`$CFG_MYSQL_CONFIG --include 2>/dev/null | filterIncludeOptions`
|
|
QT_LFLAGS_MYSQL_R=`$CFG_MYSQL_CONFIG --libs_r 2>/dev/null | filterLibraryOptions`
|
|
QT_LFLAGS_MYSQL=`$CFG_MYSQL_CONFIG --libs 2>/dev/null | filterLibraryOptions`
|
|
QT_MYSQL_VERSION=`$CFG_MYSQL_CONFIG --version 2>/dev/null`
|
|
QT_MYSQL_VERSION_MAJOR=`echo $QT_MYSQL_VERSION | cut -d . -f 1`
|
|
fi
|
|
if [ -n "$QT_MYSQL_VERSION" ] && [ "$QT_MYSQL_VERSION_MAJOR" -lt 4 ]; then
|
|
if [ "$CFG_SQL_mysql" != "auto" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
|
|
echo "This version of MySql is not supported ($QT_MYSQL_VERSION)."
|
|
echo " You need MySql 4 or higher."
|
|
echo " If you believe this message is in error you may use the continue"
|
|
echo " switch (-continue) to $0 to continue."
|
|
exit 101
|
|
else
|
|
CFG_SQL_mysql="no"
|
|
QT_LFLAGS_MYSQL=""
|
|
QT_LFLAGS_MYSQL_R=""
|
|
QT_CFLAGS_MYSQL=""
|
|
fi
|
|
else
|
|
if compileTest unix/mysql_r "MySQL (thread-safe)" $QT_LFLAGS_MYSQL_R $QT_CFLAGS_MYSQL; then
|
|
QMakeVar add CONFIG use_libmysqlclient_r
|
|
if [ "$CFG_SQL_mysql" = "auto" ]; then
|
|
CFG_SQL_mysql=plugin
|
|
fi
|
|
QT_LFLAGS_MYSQL="$QT_LFLAGS_MYSQL_R"
|
|
elif compileTest unix/mysql "MySQL (thread-unsafe)" $QT_LFLAGS_MYSQL $QT_CFLAGS_MYSQL; then
|
|
if [ "$CFG_SQL_mysql" = "auto" ]; then
|
|
CFG_SQL_mysql=plugin
|
|
fi
|
|
else
|
|
if [ "$CFG_SQL_mysql" != "auto" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
|
|
echo "MySQL support cannot be enabled due to functionality tests!"
|
|
echo " Turn on verbose messaging (-v) to $0 to see the final report."
|
|
echo " If you believe this message is in error you may use the continue"
|
|
echo " switch (-continue) to $0 to continue."
|
|
exit 101
|
|
else
|
|
CFG_SQL_mysql=no
|
|
QT_LFLAGS_MYSQL=""
|
|
QT_LFLAGS_MYSQL_R=""
|
|
QT_CFLAGS_MYSQL=""
|
|
fi
|
|
fi
|
|
fi
|
|
fi
|
|
;;
|
|
psql)
|
|
if [ "$CFG_SQL_psql" != "no" ]; then
|
|
# Be careful not to use native pg_config when cross building.
|
|
if [ "$XPLATFORM_MINGW" != "yes" ] && "$WHICH" pg_config >/dev/null 2>&1; then
|
|
QT_CFLAGS_PSQL=`pg_config --includedir 2>/dev/null | filterIncludePath`
|
|
QT_LFLAGS_PSQL=`pg_config --libdir 2>/dev/null | filterLibraryPath`
|
|
fi
|
|
[ -z "$QT_CFLAGS_PSQL" ] || QT_CFLAGS_PSQL="-I$QT_CFLAGS_PSQL"
|
|
[ -z "$QT_LFLAGS_PSQL" ] || QT_LFLAGS_PSQL="-L$QT_LFLAGS_PSQL"
|
|
# But, respect PSQL_LIBS if set
|
|
[ -z "$PSQL_LIBS" ] || QT_LFLAGS_PSQL="$PSQL_LIBS"
|
|
if compileTest unix/psql "PostgreSQL" $QT_LFLAGS_PSQL $QT_CFLAGS_PSQL; then
|
|
if [ "$CFG_SQL_psql" = "auto" ]; then
|
|
CFG_SQL_psql=plugin
|
|
fi
|
|
else
|
|
if [ "$CFG_SQL_psql" != "auto" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
|
|
echo "PostgreSQL support cannot be enabled due to functionality tests!"
|
|
echo " Turn on verbose messaging (-v) to $0 to see the final report."
|
|
echo " If you believe this message is in error you may use the continue"
|
|
echo " switch (-continue) to $0 to continue."
|
|
exit 101
|
|
else
|
|
CFG_SQL_psql=no
|
|
QT_CFLAGS_PSQL=""
|
|
QT_LFLAGS_PSQL=""
|
|
fi
|
|
fi
|
|
fi
|
|
;;
|
|
odbc)
|
|
if [ "$CFG_SQL_odbc" != "no" ]; then
|
|
if [ "$XPLATFORM_MAC" != "yes" ] && compileTest unix/odbc "ODBC"; then
|
|
if [ "$CFG_SQL_odbc" = "auto" ]; then
|
|
CFG_SQL_odbc=plugin
|
|
fi
|
|
else
|
|
if compileTest unix/iodbc "iODBC"; then
|
|
QT_LFLAGS_ODBC="-liodbc"
|
|
if [ "$CFG_SQL_odbc" = "auto" ]; then
|
|
CFG_SQL_odbc=plugin
|
|
fi
|
|
else
|
|
if [ "$CFG_SQL_odbc" != "auto" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
|
|
echo "ODBC support cannot be enabled due to functionality tests!"
|
|
echo " Turn on verbose messaging (-v) to $0 to see the final report."
|
|
echo " If you believe this message is in error you may use the continue"
|
|
echo " switch (-continue) to $0 to continue."
|
|
exit 101
|
|
else
|
|
CFG_SQL_odbc=no
|
|
fi
|
|
fi
|
|
fi
|
|
fi
|
|
;;
|
|
oci)
|
|
if [ "$CFG_SQL_oci" != "no" ]; then
|
|
if compileTest unix/oci "OCI"; then
|
|
if [ "$CFG_SQL_oci" = "auto" ]; then
|
|
CFG_SQL_oci=plugin
|
|
fi
|
|
else
|
|
if [ "$CFG_SQL_oci" != "auto" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
|
|
echo "Oracle (OCI) support cannot be enabled due to functionality tests!"
|
|
echo " Turn on verbose messaging (-v) to $0 to see the final report."
|
|
echo " If you believe this message is in error you may use the continue"
|
|
echo " switch (-continue) to $0 to continue."
|
|
exit 101
|
|
else
|
|
CFG_SQL_oci=no
|
|
fi
|
|
fi
|
|
fi
|
|
;;
|
|
tds)
|
|
if [ "$CFG_SQL_tds" != "no" ]; then
|
|
[ -z "$SYBASE" ] || QT_LFLAGS_TDS="-L$SYBASE/lib"
|
|
[ -z "$SYBASE_LIBS" ] || QT_LFLAGS_TDS="$QT_LFLAGS_TDS $SYBASE_LIBS"
|
|
if compileTest unix/tds "TDS" $QT_LFLAGS_TDS; then
|
|
if [ "$CFG_SQL_tds" = "auto" ]; then
|
|
CFG_SQL_tds=plugin
|
|
fi
|
|
else
|
|
if [ "$CFG_SQL_tds" != "auto" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
|
|
echo "TDS support cannot be enabled due to functionality tests!"
|
|
echo " Turn on verbose messaging (-v) to $0 to see the final report."
|
|
echo " If you believe this message is in error you may use the continue"
|
|
echo " switch (-continue) to $0 to continue."
|
|
exit 101
|
|
else
|
|
CFG_SQL_tds=no
|
|
fi
|
|
fi
|
|
fi
|
|
;;
|
|
db2)
|
|
if [ "$CFG_SQL_db2" != "no" ]; then
|
|
if compileTest unix/db2 "DB2"; then
|
|
if [ "$CFG_SQL_db2" = "auto" ]; then
|
|
CFG_SQL_db2=plugin
|
|
fi
|
|
else
|
|
if [ "$CFG_SQL_db2" != "auto" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
|
|
echo "ODBC support cannot be enabled due to functionality tests!"
|
|
echo " Turn on verbose messaging (-v) to $0 to see the final report."
|
|
echo " If you believe this message is in error you may use the continue"
|
|
echo " switch (-continue) to $0 to continue."
|
|
exit 101
|
|
else
|
|
CFG_SQL_db2=no
|
|
fi
|
|
fi
|
|
fi
|
|
;;
|
|
ibase)
|
|
if [ "$CFG_SQL_ibase" != "no" ]; then
|
|
if compileTest unix/ibase "InterBase"; then
|
|
if [ "$CFG_SQL_ibase" = "auto" ]; then
|
|
CFG_SQL_ibase=plugin
|
|
fi
|
|
else
|
|
if [ "$CFG_SQL_ibase" != "auto" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
|
|
echo "InterBase support cannot be enabled due to functionality tests!"
|
|
echo " Turn on verbose messaging (-v) to $0 to see the final report."
|
|
echo " If you believe this message is in error you may use the continue"
|
|
echo " switch (-continue) to $0 to continue."
|
|
exit 101
|
|
else
|
|
CFG_SQL_ibase=no
|
|
fi
|
|
fi
|
|
fi
|
|
;;
|
|
sqlite2)
|
|
if [ "$CFG_SQL_sqlite2" != "no" ]; then
|
|
if compileTest unix/sqlite2 "SQLite2"; then
|
|
if [ "$CFG_SQL_sqlite2" = "auto" ]; then
|
|
CFG_SQL_sqlite2=plugin
|
|
fi
|
|
else
|
|
if [ "$CFG_SQL_sqlite2" != "auto" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
|
|
echo "SQLite2 support cannot be enabled due to functionality tests!"
|
|
echo " Turn on verbose messaging (-v) to $0 to see the final report."
|
|
echo " If you believe this message is in error you may use the continue"
|
|
echo " switch (-continue) to $0 to continue."
|
|
exit 101
|
|
else
|
|
CFG_SQL_sqlite2=no
|
|
fi
|
|
fi
|
|
fi
|
|
;;
|
|
sqlite)
|
|
if [ "$CFG_SQL_sqlite" != "no" ]; then
|
|
SQLITE_AUTODETECT_FAILED="no"
|
|
if [ "$CFG_SQLITE" = "system" ]; then
|
|
if [ -n "$PKG_CONFIG" ] && $PKG_CONFIG --exists sqlite3 2>/dev/null; then
|
|
QT_CFLAGS_SQLITE=`$PKG_CONFIG --cflags sqlite3 2>/dev/null`
|
|
QT_LFLAGS_SQLITE=`$PKG_CONFIG --libs sqlite3 2>/dev/null`
|
|
else
|
|
QT_CFLAGS_SQLITE=
|
|
QT_LFLAGS_SQLITE="-lsqlite3 -lz"
|
|
fi
|
|
if compileTest unix/sqlite "SQLite" $QT_LFLAGS_SQLITE $QT_CFLAGS_SQLITE; then
|
|
if [ "$CFG_SQL_sqlite" = "auto" ]; then
|
|
CFG_SQL_sqlite=plugin
|
|
fi
|
|
QMAKE_CONFIG="$QMAKE_CONFIG system-sqlite"
|
|
else
|
|
SQLITE_AUTODETECT_FAILED="yes"
|
|
CFG_SQL_sqlite=no
|
|
fi
|
|
elif [ -f "$relpath/src/3rdparty/sqlite/sqlite3.h" ]; then
|
|
if [ "$CFG_SQL_sqlite" = "auto" ]; then
|
|
CFG_SQL_sqlite=plugin
|
|
fi
|
|
else
|
|
SQLITE_AUTODETECT_FAILED="yes"
|
|
CFG_SQL_sqlite=no
|
|
fi
|
|
|
|
if [ "$SQLITE_AUTODETECT_FAILED" = "yes" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
|
|
echo "SQLite support cannot be enabled due to functionality tests!"
|
|
echo " Turn on verbose messaging (-v) to $0 to see the final report."
|
|
echo " If you believe this message is in error you may use the continue"
|
|
echo " switch (-continue) to $0 to continue."
|
|
exit 101
|
|
fi
|
|
fi
|
|
;;
|
|
*)
|
|
if [ "$OPT_VERBOSE" = "yes" ]; then
|
|
echo "unknown SQL driver: $_SQLDR"
|
|
fi
|
|
;;
|
|
esac
|
|
done
|
|
|
|
# auto-detect NIS support
|
|
if [ "$CFG_NIS" != "no" ]; then
|
|
if compileTest unix/nis "NIS"; then
|
|
CFG_NIS=yes
|
|
else
|
|
if [ "$CFG_NIS" = "yes" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
|
|
echo "NIS support cannot be enabled due to functionality tests!"
|
|
echo " Turn on verbose messaging (-v) to $0 to see the final report."
|
|
echo " If you believe this message is in error you may use the continue"
|
|
echo " switch (-continue) to $0 to continue."
|
|
exit 101
|
|
else
|
|
CFG_NIS=no
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
# auto-detect CUPS support
|
|
if [ "$CFG_CUPS" != "no" ]; then
|
|
if compileTest unix/cups "Cups"; then
|
|
CFG_CUPS=yes
|
|
else
|
|
if [ "$CFG_CUPS" = "yes" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
|
|
echo "Cups support cannot be enabled due to functionality tests!"
|
|
echo " Turn on verbose messaging (-v) to $0 to see the final report."
|
|
echo " If you believe this message is in error you may use the continue"
|
|
echo " switch (-continue) to $0 to continue."
|
|
exit 101
|
|
else
|
|
CFG_CUPS=no
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
# auto-detect iconv(3) support
|
|
if [ "$CFG_ICONV" != "no" ]; then
|
|
if [ "$XPLATFORM_MINGW" = "yes" ]; then
|
|
CFG_ICONV=no
|
|
elif compileTest unix/iconv "POSIX iconv"; then
|
|
CFG_ICONV=yes
|
|
elif compileTest unix/sun-libiconv "SUN libiconv"; then
|
|
CFG_ICONV=sun
|
|
elif compileTest unix/gnu-libiconv "GNU libiconv"; then
|
|
CFG_ICONV=gnu
|
|
else
|
|
if [ "$CFG_ICONV" = "yes" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
|
|
echo "Iconv support cannot be enabled due to functionality tests!"
|
|
echo " Turn on verbose messaging (-v) to $0 to see the final report."
|
|
echo " If you believe this message is in error you may use the continue"
|
|
echo " switch (-continue) to $0 to continue."
|
|
exit 101
|
|
else
|
|
CFG_ICONV=no
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
# auto-detect libdbus-1 support
|
|
if [ "$CFG_DBUS" != "no" ]; then
|
|
if [ -n "$PKG_CONFIG" ] && $PKG_CONFIG --atleast-version="$MIN_DBUS_1_VERSION" dbus-1 2>/dev/null; then
|
|
QT_CFLAGS_DBUS=`$PKG_CONFIG --cflags dbus-1 2>/dev/null`
|
|
QT_LIBS_DBUS=`$PKG_CONFIG --libs dbus-1 2>/dev/null`
|
|
fi
|
|
if compileTest unix/dbus "D-Bus" $QT_CFLAGS_DBUS $QT_LIBS_DBUS; then
|
|
[ "$CFG_DBUS" = "auto" ] && CFG_DBUS=yes
|
|
QMakeVar set QT_CFLAGS_DBUS "$QT_CFLAGS_DBUS"
|
|
QMakeVar set QT_LIBS_DBUS "$QT_LIBS_DBUS"
|
|
else
|
|
if [ "$CFG_DBUS" = "auto" ]; then
|
|
CFG_DBUS=no
|
|
elif [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
|
|
# CFG_DBUS is "yes" or "linked" here
|
|
|
|
echo "The Qt D-Bus module cannot be enabled because libdbus-1 version $MIN_DBUS_1_VERSION was not found."
|
|
echo " Turn on verbose messaging (-v) to $0 to see the final report."
|
|
echo " If you believe this message is in error you may use the continue"
|
|
echo " switch (-continue) to $0 to continue."
|
|
exit 101
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
# auto-detect Glib support
|
|
if [ "$CFG_GLIB" != "no" ]; then
|
|
if [ -n "$PKG_CONFIG" ]; then
|
|
QT_CFLAGS_GLIB=`$PKG_CONFIG --cflags glib-2.0 gthread-2.0 2>/dev/null`
|
|
QT_LIBS_GLIB=`$PKG_CONFIG --libs glib-2.0 gthread-2.0 2>/dev/null`
|
|
fi
|
|
if compileTest unix/glib "Glib" $QT_CFLAGS_GLIB $QT_LIBS_GLIB; then
|
|
CFG_GLIB=yes
|
|
QMakeVar set QT_CFLAGS_GLIB "$QT_CFLAGS_GLIB"
|
|
QMakeVar set QT_LIBS_GLIB "$QT_LIBS_GLIB"
|
|
else
|
|
if [ "$CFG_GLIB" = "yes" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
|
|
echo "Glib support cannot be enabled due to functionality tests!"
|
|
echo " Turn on verbose messaging (-v) to $0 to see the final report."
|
|
echo " If you believe this message is in error you may use the continue"
|
|
echo " switch (-continue) to $0 to continue."
|
|
exit 101
|
|
else
|
|
CFG_GLIB=no
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
# auto-detect GTK style support
|
|
if [ "$CFG_GLIB" = "yes" -a "$CFG_QGTKSTYLE" != "no" ]; then
|
|
if [ -n "$PKG_CONFIG" ]; then
|
|
QT_CFLAGS_QGTK2=`$PKG_CONFIG --cflags gtk+-2.0 ">=" 2.18 atk 2>/dev/null`
|
|
QT_LIBS_QGTK2=`$PKG_CONFIG --libs gtk+-2.0 2>/dev/null`
|
|
QT_LIBS_QGOBJECT=`$PKG_CONFIG --libs gobject-2.0 2>/dev/null`
|
|
fi
|
|
if [ -n "$QT_CFLAGS_QGTK2" ] ; then
|
|
CFG_QGTKSTYLE=yes
|
|
QT_CONFIG="$QT_CONFIG gtk2 gtkstyle"
|
|
QMakeVar set QT_CFLAGS_QGTKSTYLE "$QT_CFLAGS_QGTK2"
|
|
QMakeVar set QT_LIBS_QGTKSTYLE "$QT_LIBS_QGOBJECT"
|
|
QMakeVar set QT_CFLAGS_QGTK2 "$QT_CFLAGS_QGTK2"
|
|
QMakeVar set QT_LIBS_QGTK2 "$QT_LIBS_QGTK2"
|
|
else
|
|
if [ "$CFG_QGTKSTYLE" = "yes" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
|
|
echo "Gtk theme support cannot be enabled due to functionality tests!"
|
|
echo " Turn on verbose messaging (-v) to $0 to see the fin al report."
|
|
echo " If you believe this message is in error you may use the continue"
|
|
echo " switch (-continue) to $0 to continue."
|
|
exit 101
|
|
else
|
|
CFG_QGTKSTYLE=no
|
|
fi
|
|
fi
|
|
elif [ "$CFG_GLIB" = "no" ]; then
|
|
CFG_QGTKSTYLE=no
|
|
fi
|
|
|
|
# auto-detect libicu support
|
|
if [ "$CFG_ICU" != "no" ]; then
|
|
if compileTest unix/icu "ICU"; then
|
|
[ "$CFG_ICU" = "auto" ] && CFG_ICU=yes
|
|
else
|
|
if [ "$CFG_ICU" = "auto" ]; then
|
|
CFG_ICU=no
|
|
elif [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
|
|
# CFG_ICU is "yes"
|
|
|
|
echo "The ICU library support cannot be enabled."
|
|
echo " Turn on verbose messaging (-v) to $0 to see the final report."
|
|
echo " If you believe this message is in error you may use the continue"
|
|
echo " switch (-continue) to $0 to continue."
|
|
exit 101
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
# Auto-detect PulseAudio support
|
|
if [ "$CFG_PULSEAUDIO" != "no" ]; then
|
|
if [ -n "$PKG_CONFIG" ]; then
|
|
QT_CFLAGS_PULSEAUDIO=`$PKG_CONFIG --cflags libpulse '>=' 0.9.10 libpulse-mainloop-glib 2>/dev/null`
|
|
QT_LIBS_PULSEAUDIO=`$PKG_CONFIG --libs libpulse '>=' 0.9.10 libpulse-mainloop-glib 2>/dev/null`
|
|
fi
|
|
if compileTest unix/pulseaudio "PulseAudio" $QT_CFLAGS_PULSEAUDIO $QT_LIBS_PULSEAUDIO; then
|
|
CFG_PULSEAUDIO=yes
|
|
QMakeVar set QT_CFLAGS_PULSEAUDIO "$QT_CFLAGS_PULSEAUDIO"
|
|
QMakeVar set QT_LIBS_PULSEAUDIO "$QT_LIBS_PULSEAUDIO"
|
|
else
|
|
if [ "$CFG_PULSEAUDIO" = "yes" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
|
|
echo "PulseAudio support cannot be enabled due to functionality tests!"
|
|
echo " Turn on verbose messaging (-v) to $0 to see the final report."
|
|
echo " If you believe this message is in error you may use the continue"
|
|
echo " switch (-continue) to $0 to continue."
|
|
exit 101
|
|
else
|
|
CFG_PULSEAUDIO=no
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
# X11/MINGW OpenGL
|
|
if [ "$XPLATFORM_MINGW" = "yes" ]; then
|
|
# auto-detect OpenGL support (es2 = OpenGL ES 2.x)
|
|
if [ "$CFG_GUI" = "no" ]; then
|
|
if [ "$CFG_OPENGL" = "auto" ]; then
|
|
CFG_OPENGL=no
|
|
fi
|
|
if [ "$CFG_OPENGL" != "no" ]; then
|
|
echo "OpenGL enabled, but GUI disabled."
|
|
echo " You might need to either enable the GUI or disable OpenGL"
|
|
exit 1
|
|
fi
|
|
fi
|
|
if [ "$CFG_OPENGL" = "auto" ] || [ "$CFG_OPENGL" = "yes" ]; then
|
|
if compileTest x11/opengl "OpenGL"; then
|
|
CFG_OPENGL=desktop
|
|
elif compileTest unix/opengles2 "OpenGL ES 2.x"; then
|
|
CFG_OPENGL=es2
|
|
else
|
|
if [ "$CFG_OPENGL" = "yes" ]; then
|
|
echo "All the OpenGL functionality tests failed!"
|
|
echo " You might need to modify the include and library search paths by editing"
|
|
echo " QMAKE_INCDIR_OPENGL, QMAKE_LIBDIR_OPENGL and QMAKE_LIBS_OPENGL in"
|
|
echo " ${XQMAKESPEC}."
|
|
exit 1
|
|
fi
|
|
CFG_OPENGL=no
|
|
fi
|
|
elif [ "$CFG_OPENGL" = "es2" ]; then
|
|
#OpenGL ES 2.x
|
|
compileTest unix/opengles2 "OpenGL ES 2.x"
|
|
if [ $? != "0" ]; then
|
|
echo "The OpenGL ES 2.0 functionality test failed!"
|
|
echo " You might need to modify the include and library search paths by editing"
|
|
echo " QMAKE_INCDIR_OPENGL_ES2, QMAKE_LIBDIR_OPENGL_ES2 and QMAKE_LIBS_OPENGL_ES2 in"
|
|
echo " ${XQMAKESPEC}."
|
|
exit 1
|
|
fi
|
|
elif [ "$CFG_OPENGL" = "desktop" ]; then
|
|
# Desktop OpenGL support
|
|
compileTest x11/opengl "OpenGL"
|
|
if [ $? != "0" ]; then
|
|
echo "The OpenGL functionality test failed!"
|
|
echo " You might need to modify the include and library search paths by editing"
|
|
echo " QMAKE_INCDIR_OPENGL, QMAKE_LIBDIR_OPENGL and QMAKE_LIBS_OPENGL in"
|
|
echo " ${XQMAKESPEC}."
|
|
exit 1
|
|
fi
|
|
fi
|
|
fi # X11/MINGW OpenGL
|
|
|
|
if [ "$XPLATFORM_MAC" = "yes" ]; then
|
|
if [ "$CFG_COREWLAN" = "auto" ]; then
|
|
if compileTest mac/corewlan "CoreWlan"; then
|
|
CFG_COREWLAN=yes
|
|
else
|
|
CFG_COREWLAN=no
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
# auto-detect OpenGL support (es2 = OpenGL ES 2.x)
|
|
if [ "$CFG_OPENGL" = "auto" ] || [ "$CFG_OPENGL" = "yes" ]; then
|
|
if compileTest unix/opengldesktop "OpenGL"; then
|
|
CFG_OPENGL=desktop
|
|
elif compileTest unix/opengles2 "OpenGL ES 2.x"; then
|
|
CFG_OPENGL=es2
|
|
else
|
|
if [ "$CFG_OPENGL" = "yes" ]; then
|
|
echo "All the OpenGL functionality tests failed!"
|
|
echo " You might need to modify the include and library search paths by editing"
|
|
echo " QMAKE_INCDIR_OPENGL, QMAKE_LIBDIR_OPENGL and QMAKE_LIBS_OPENGL in"
|
|
echo " ${XQMAKESPEC}."
|
|
exit 1
|
|
fi
|
|
CFG_OPENGL=no
|
|
fi
|
|
elif [ "$CFG_OPENGL" = "es2" ]; then
|
|
#OpenGL ES 2.x
|
|
if [ -n "$PKG_CONFIG" ] && $PKG_CONFIG --exists glesv2 2>/dev/null; then
|
|
QMAKE_INCDIR_OPENGL_ES2=`$PKG_CONFIG --cflags-only-I glesv2 2>/dev/null | sed -e 's,^-I,,g' -e 's, -I, ,g'`
|
|
QMAKE_LIBDIR_OPENGL_ES2=`$PKG_CONFIG --libs-only-L glesv2 2>/dev/null | sed -e 's,^-L,,g' -e 's, -L, ,g'`
|
|
QMAKE_LIBS_OPENGL_ES2=`$PKG_CONFIG --libs glesv2 2>/dev/null`
|
|
QMAKE_CFLAGS_OPENGL_ES2=`$PKG_CONFIG --cflags glesv2 2>/dev/null`
|
|
QMakeVar set QMAKE_INCDIR_OPENGL_ES2 "`shellArgumentListToQMakeList "$QMAKE_INCDIR_OPENGL_ES2"`"
|
|
QMakeVar set QMAKE_LIBDIR_OPENGL_ES2 "`shellArgumentListToQMakeList "$QMAKE_LIBDIR_OPENGL_ES2"`"
|
|
QMakeVar set QMAKE_LIBS_OPENGL_ES2 "`shellArgumentListToQMakeList "$QMAKE_LIBS_OPENGL_ES2"`"
|
|
fi
|
|
|
|
compileTest unix/opengles2 "OpenGL ES 2.x" $QMAKE_LIBS_OPENGL_ES2 $QMAKE_CFLAGS_OPENGL_ES2
|
|
if [ $? != "0" ]; then
|
|
echo "The OpenGL ES 2.0 functionality test failed!"
|
|
echo " You might need to modify the include and library search paths by editing"
|
|
echo " QMAKE_INCDIR_OPENGL_ES2, QMAKE_LIBDIR_OPENGL_ES2 and QMAKE_LIBS_OPENGL_ES2 in"
|
|
echo " ${XQMAKESPEC}."
|
|
exit 1
|
|
fi
|
|
elif [ "$CFG_OPENGL" = "desktop" ]; then
|
|
# Desktop OpenGL support
|
|
compileTest unix/opengldesktop "OpenGL"
|
|
if [ $? != "0" ]; then
|
|
echo "The OpenGL functionality test failed!"
|
|
echo " You might need to modify the include and library search paths by editing"
|
|
echo " QMAKE_INCDIR_OPENGL, QMAKE_LIBDIR_OPENGL and QMAKE_LIBS_OPENGL in"
|
|
echo " ${XQMAKESPEC}."
|
|
exit 1
|
|
fi
|
|
fi
|
|
|
|
# auto-detect FontConfig support
|
|
if [ "$CFG_FONTCONFIG" != "no" ]; then
|
|
if [ -n "$PKG_CONFIG" ] && $PKG_CONFIG --exists fontconfig --exists freetype2 2>/dev/null; then
|
|
QT_CFLAGS_FONTCONFIG=`$PKG_CONFIG --cflags fontconfig --cflags freetype2 2>/dev/null`
|
|
QT_LIBS_FONTCONFIG=`$PKG_CONFIG --libs fontconfig --libs freetype2 2>/dev/null`
|
|
else
|
|
QT_CFLAGS_FONTCONFIG=
|
|
QT_LIBS_FONTCONFIG="-lfreetype -lfontconfig"
|
|
fi
|
|
if compileTest unix/fontconfig "FontConfig" $QT_CFLAGS_FONTCONFIG $QT_LIBS_FONTCONFIG; then
|
|
QT_CONFIG="$QT_CONFIG fontconfig"
|
|
QMakeVar set QMAKE_CFLAGS_FONTCONFIG "$QT_CFLAGS_FONTCONFIG"
|
|
QMakeVar set QMAKE_LIBS_FONTCONFIG "$QT_LIBS_FONTCONFIG"
|
|
CFG_FONTCONFIG=yes
|
|
CFG_FREETYPE=system
|
|
else
|
|
CFG_FONTCONFIG=no
|
|
fi
|
|
|
|
fi
|
|
|
|
# Save these for a check later
|
|
ORIG_CFG_XCB="$CFG_XCB"
|
|
ORIG_CFG_EGLFS="$CFG_EGLFS"
|
|
ORIG_CFG_DIRECTFB="$CFG_DIRECTFB"
|
|
ORIG_CFG_LINUXFB="$CFG_LINUXFB"
|
|
ORIG_CFG_KMS="$CFG_KMS"
|
|
|
|
if [ "$CFG_LIBUDEV" != "no" ]; then
|
|
if [ -n "$PKG_CONFIG" ] && $PKG_CONFIG --exists libudev 2>/dev/null; then
|
|
QMAKE_INCDIR_LIBUDEV=`$PKG_CONFIG --cflags-only-I libudev 2>/dev/null | sed -e 's,^-I,,g' -e 's, -I, ,g'`
|
|
QMAKE_LIBS_LIBUDEV=`$PKG_CONFIG --libs libudev 2>/dev/null`
|
|
QMakeVar set QMAKE_INCDIR_LIBUDEV "$QMAKE_INCDIR_LIBUDEV"
|
|
QMakeVar set QMAKE_LIBS_LIBUDEV "$QMAKE_LIBS_LIBUDEV"
|
|
fi
|
|
if compileTest unix/libudev "libudev" $QMAKE_INCDIR_LIBUDEV $QMAKE_LIBS_LIBUDEV; then
|
|
CFG_LIBUDEV=yes
|
|
QT_CONFIG="$QT_CONFIG libudev"
|
|
elif [ "$CFG_LIBUDEV" = "yes" ]; then
|
|
echo "The libudev functionality test failed!"
|
|
exit 1
|
|
else
|
|
CFG_LIBUDEV=no
|
|
fi
|
|
fi
|
|
if [ "$CFG_LIBUDEV" = "no" ]; then
|
|
QMakeVar add DEFINES QT_NO_LIBUDEV
|
|
fi
|
|
|
|
if [ "$CFG_EVDEV" != "no" ]; then
|
|
if compileTest unix/evdev "evdev"; then
|
|
CFG_EVDEV=yes
|
|
QT_CONFIG="$QT_CONFIG evdev"
|
|
elif [ "$CFG_EVDEV" = "yes" ]; then
|
|
echo "The evdev functionality test failed!"
|
|
exit 1
|
|
else
|
|
CFG_EVDEV=no
|
|
fi
|
|
fi
|
|
if [ "$CFG_EVDEV" = "no" ]; then
|
|
QMakeVar add DEFINES QT_NO_EVDEV
|
|
fi
|
|
|
|
if [ "$CFG_TSLIB" != "no" ]; then
|
|
if compileTest unix/tslib "tslib"; then
|
|
CFG_TSLIB=yes
|
|
QT_CONFIG="$QT_CONFIG tslib"
|
|
elif [ "$CFG_TSLIB" = "yes" ]; then
|
|
echo "The tslib functionality test failed!"
|
|
exit 1
|
|
else
|
|
CFG_TSLIB=no
|
|
fi
|
|
fi
|
|
|
|
if [ "$CFG_XCB" != "no" ]; then
|
|
if [ -n "$PKG_CONFIG" ] && $PKG_CONFIG --exists "xcb >= 1.5" 2>/dev/null; then
|
|
QMAKE_CFLAGS_XCB="`$PKG_CONFIG --cflags xcb 2>/dev/null`"
|
|
QMAKE_LIBS_XCB="`$PKG_CONFIG --libs xcb 2>/dev/null`"
|
|
fi
|
|
if compileTest qpa/xcb "xcb" $QMAKE_CFLAGS_XCB $QMAKE_LIBS_XCB; then
|
|
|
|
if [ "$CFG_XCB" = "qt" ]; then
|
|
QT_CONFIG="$QT_CONFIG xcb-qt"
|
|
else
|
|
CFG_XCB="system"
|
|
|
|
if [ -n "$PKG_CONFIG" ] && $PKG_CONFIG --exists "xcb >= 1.5" 2>/dev/null; then
|
|
XCB_PACKAGES="xcb xcb-shm xcb-sync xcb-xfixes xcb-randr xcb-image xcb-keysyms xcb-icccm"
|
|
QMAKE_CFLAGS_XCB="`$PKG_CONFIG --cflags $XCB_PACKAGES 2>/dev/null`"
|
|
QMAKE_LIBS_XCB="`$PKG_CONFIG --libs $XCB_PACKAGES 2>/dev/null`"
|
|
# for xcb-xkb tests
|
|
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
|
|
CFG_XKB=no
|
|
QMakeVar add DEFINES QT_NO_XKB
|
|
fi
|
|
|
|
if compileTest qpa/xcb-syslibs "xcb-syslibs" $QMAKE_CFLAGS_XCB $QMAKE_LIBS_XCB; then
|
|
if compileTest qpa/xcb-render "xcb-render" $QMAKE_CFLAGS_XCB $QMAKE_LIBS_XCB; then
|
|
QT_CONFIG="$QT_CONFIG xcb-render"
|
|
fi
|
|
|
|
if compileTest qpa/xcb-glx "xcb-glx" $QMAKE_CFLAGS_XCB $QMAKE_LIBS_XCB; then
|
|
CFG_XCB_GLX=yes
|
|
QT_CONFIG="$QT_CONFIG xcb-glx"
|
|
fi
|
|
else
|
|
echo "The test for linking against libxcb and support libraries failed!"
|
|
echo " You might need to install dependency packages, or pass -qt-xcb."
|
|
echo " See src/plugins/platforms/xcb/README."
|
|
exit 1
|
|
fi
|
|
fi
|
|
|
|
# Check for X11. Eventually we should port everything to XCB,
|
|
# but for now the port is incomplete and Xlib is a requirement.
|
|
if compileTest x11/xlib "XLib"; then
|
|
QT_CONFIG="$QT_CONFIG xlib"
|
|
else
|
|
echo "The test for linking against Xlib failed!"
|
|
echo " You might need to install dependency packages."
|
|
echo " See src/plugins/platforms/xcb/README."
|
|
exit 1
|
|
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"
|
|
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
|
|
|
|
# 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. Needed by xcb too.
|
|
if [ "$CFG_XINPUT2" != "no" ]; then
|
|
if compileTest x11/xinput2 "XInput2"; then
|
|
CFG_XINPUT2=yes
|
|
CFG_XINPUT=no
|
|
else
|
|
if [ "$CFG_XINPUT2" = "yes" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
|
|
echo "XInput2 support cannot be enabled due to functionality tests!"
|
|
echo " Turn on verbose messaging (-v) to $0 to see the final report."
|
|
echo " If you believe this message is in error you may use the continue"
|
|
echo " switch (-continue) to $0 to continue."
|
|
exit 101
|
|
else
|
|
CFG_XINPUT2=no
|
|
fi
|
|
fi
|
|
fi
|
|
else
|
|
if [ "$CFG_XCB" != "auto" ]; then
|
|
echo "The test for linking against libxcb failed!"
|
|
echo " You might need to install dependency packages for libxcb."
|
|
echo " See src/plugins/platforms/xcb/README."
|
|
exit 1
|
|
fi
|
|
CFG_XCB=no
|
|
fi
|
|
fi
|
|
if [ "$CFG_XCB" = "no" ]; then
|
|
QMakeVar add DEFINES QT_NO_XCB
|
|
fi
|
|
|
|
if [ "$CFG_DIRECTFB" != "no" ]; then
|
|
if [ -n "$PKG_CONFIG" ] && $PKG_CONFIG --exists directfb 2>/dev/null; then
|
|
QMAKE_CFLAGS_DIRECTFB=`$PKG_CONFIG --cflags directfb 2>/dev/null`
|
|
QMAKE_LIBS_DIRECTFB=`$PKG_CONFIG --libs directfb 2>/dev/null`
|
|
if compileTest qpa/directfb "DirectFB" $QMAKE_CFLAGS_DIRECTFB $QMAKE_LIBS_DIRECTFB; then
|
|
CFG_DIRECTFB=yes
|
|
elif [ "$CFG_DIRECTFB" = "yes" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
|
|
echo " DirectFB support cannot be enabled due to functionality tests!"
|
|
echo " Turn on verbose messaging (-v) to $0 to see the final report."
|
|
echo " If you believe this message is in error you may use the continue"
|
|
echo " switch (-continue) to $0 to continue."
|
|
exit 101
|
|
else
|
|
CFG_DIRECTFB=no
|
|
fi
|
|
else
|
|
CFG_DIRECTFB=no
|
|
fi
|
|
fi
|
|
|
|
if [ "$CFG_LINUXFB" != "no" ]; then
|
|
if compileTest qpa/linuxfb "LinuxFB"; then
|
|
CFG_LINUXFB=yes
|
|
elif [ "$CFG_LINUXFB" = "yes" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
|
|
echo " Linux Framebuffer support cannot be enabled due to functionality tests!"
|
|
echo " Turn on verbose messaging (-v) to $0 to see the final report."
|
|
echo " If you believe this message is in error you may use the continue"
|
|
echo " switch (-continue) to $0 to continue."
|
|
exit 101
|
|
else
|
|
CFG_LINUXFB=no
|
|
fi
|
|
fi
|
|
|
|
if [ "$CFG_KMS" != "no" ]; then
|
|
if compileTest qpa/kms "KMS"; then
|
|
CFG_KMS=yes
|
|
elif [ "$CFG_KMS" = "yes" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
|
|
echo " KMS support cannot be enabled due to functionality tests!"
|
|
echo " Turn on verbose messaging (-v) to $0 to see the final report."
|
|
echo " If you believe this message is in error you may use the continue"
|
|
echo " switch (-continue) to $0 to continue."
|
|
exit 101
|
|
else
|
|
CFG_KMS=no
|
|
fi
|
|
fi
|
|
|
|
# Detect libxkbcommon
|
|
ORIG_CFG_XKBCOMMON="$CFG_XKBCOMMON"
|
|
if [ "$CFG_XKBCOMMON" != "qt" ]; then
|
|
# currently only xcb platform plugin requires xkbcommon, for other platforms it can be set to 'no'
|
|
if [ "$CFG_XKBCOMMON" != "no" ]; then
|
|
if [ -n "$PKG_CONFIG" ] && $PKG_CONFIG --exists "xkbcommon >= 0.2.0" 2>/dev/null; then
|
|
QMAKE_CFLAGS_XKBCOMMON="`$PKG_CONFIG --cflags xkbcommon 2>/dev/null`"
|
|
QMAKE_LIBS_XKBCOMMON="`$PKG_CONFIG --libs xkbcommon 2>/dev/null`"
|
|
QMAKE_VERSION_XKBCOMMON="`$PKG_CONFIG --modversion xkbcommon 2>/dev/null`"
|
|
|
|
QMakeVar set QMAKE_CFLAGS_XKBCOMMON "$QMAKE_CFLAGS_XKBCOMMON"
|
|
QMakeVar set QMAKE_LIBS_XKBCOMMON "$QMAKE_LIBS_XKBCOMMON"
|
|
QMakeVar set QMAKE_VERSION_XKBCOMMON "$QMAKE_VERSION_XKBCOMMON"
|
|
CFG_XKBCOMMON=system
|
|
else
|
|
CFG_XKBCOMMON=no
|
|
fi
|
|
|
|
if [ "$CFG_XCB" != "no" ] && [ "$CFG_XKBCOMMON" = "no" ]; then
|
|
# use the bundled version instead
|
|
CFG_XKBCOMMON=qt
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
if [ "$CFG_XKBCOMMON" = "qt" ]; then
|
|
QT_CONFIG="$QT_CONFIG xkbcommon-qt"
|
|
elif [ "$CFG_XKBCOMMON" = "no" ]; then
|
|
QMakeVar add DEFINES QT_NO_XKBCOMMON
|
|
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
|
|
elif [ "$CFG_EGL" = "yes" ]; then
|
|
echo " The EGL functionality test failed; EGL is required by some QPA plugins to manage contexts & surfaces."
|
|
echo " You might need to modify the include and library search paths by editing"
|
|
echo " QMAKE_INCDIR_EGL, QMAKE_LIBDIR_EGL and QMAKE_LIBS_EGL in ${XQMAKESPEC}."
|
|
exit 1
|
|
else
|
|
CFG_EGL=no
|
|
fi
|
|
fi
|
|
|
|
# GLX Support
|
|
if [ "$CFG_GLX" != "no" ]; then
|
|
if [ "$CFG_GLX" = "yes" ] && [ "$CFG_OPENGL" = "no" ]; then
|
|
echo "GLX support was requested but OpenGL support is disabled."
|
|
echo "Either disable GLX support or enable OpenGL support."
|
|
exit 101
|
|
fi
|
|
if compileTest qpa/glx "GLX"; then
|
|
CFG_GLX=yes
|
|
elif [ "$CFG_GLX" = "yes" ]; then
|
|
echo " The GLX functionality test failed; GLX is required by the xcb plugin to manage contexts & surfaces."
|
|
exit 1
|
|
else
|
|
CFG_GLX=no
|
|
fi
|
|
fi
|
|
|
|
|
|
if [ "$CFG_EGLFS" != "no" ]; then
|
|
if [ "$XPLATFORM_QNX" = "no" ]; then
|
|
CFG_EGLFS="$CFG_EGL"
|
|
else
|
|
CFG_EGLFS="no"
|
|
fi
|
|
fi
|
|
|
|
if [ "$CFG_KMS" = "yes" ]; then
|
|
if [ "$CFG_EGL" = "yes" ]; then
|
|
CFG_KMS="yes"
|
|
else
|
|
CFG_KMS="no"
|
|
fi
|
|
fi
|
|
|
|
# Detect accessibility support
|
|
if [ "$CFG_ACCESSIBILITY" = "no" ]; then
|
|
echo >&2 "Warning: Disabling Accessibility. This version of Qt is unsupported."
|
|
else
|
|
CFG_ACCESSIBILITY=yes
|
|
|
|
# linux/xcb accessibility bridge needs dbus
|
|
if [ "$CFG_XCB" != "no" ]; then
|
|
if [ "$CFG_DBUS" != "no" ]; then
|
|
CFG_ACCESSIBILITY_ATSPI_BRIDGE=yes
|
|
QT_CONFIG="$QT_CONFIG accessibility-atspi-bridge"
|
|
else
|
|
echo >&2 "Warning: Disabling Linux Accessibility Bridge: DBus is missing."
|
|
QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_ACCESSIBILITY_ATSPI_BRIDGE"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
# Determine the default QPA platform
|
|
if [ -z "$QT_QPA_DEFAULT_PLATFORM" ]; then
|
|
# check the mkspec
|
|
QT_QPA_DEFAULT_PLATFORM=`getXQMakeConf QT_QPA_DEFAULT_PLATFORM`
|
|
if [ -z "$QT_QPA_DEFAULT_PLATFORM" ]; then
|
|
if [ "$XPLATFORM_MINGW" = "yes" ]; then
|
|
QT_QPA_DEFAULT_PLATFORM="windows"
|
|
elif [ "$XPLATFORM_MAC" = "yes" ]; then
|
|
QT_QPA_DEFAULT_PLATFORM="cocoa"
|
|
elif [ "$UNAME_SYSTEM" = "QNX" ]; then
|
|
QT_QPA_DEFAULT_PLATFORM="qnx"
|
|
else
|
|
QT_QPA_DEFAULT_PLATFORM="xcb"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
if [ -n "$QMAKE_CFLAGS_XCB" ] || [ -n "$QMAKE_LIBS_XCB" ]; then
|
|
QMakeVar set QMAKE_CFLAGS_XCB "$QMAKE_CFLAGS_XCB"
|
|
QMakeVar set QMAKE_LIBS_XCB "$QMAKE_LIBS_XCB"
|
|
fi
|
|
|
|
if [ "$CFG_DIRECTFB" = "yes" ]; then
|
|
QT_CONFIG="$QT_CONFIG directfb"
|
|
QMakeVar set QMAKE_CFLAGS_DIRECTFB "$QMAKE_CFLAGS_DIRECTFB"
|
|
QMakeVar set QMAKE_LIBS_DIRECTFB "$QMAKE_LIBS_DIRECTFB"
|
|
fi
|
|
if [ "$CFG_LINUXFB" = "yes" ]; then
|
|
QT_CONFIG="$QT_CONFIG linuxfb"
|
|
fi
|
|
if [ "$CFG_KMS" = "yes" ]; then
|
|
QT_CONFIG="$QT_CONFIG kms"
|
|
fi
|
|
|
|
if [ "$XPLATFORM_MAC" = "no" ] && [ "$XPLATFORM_MINGW" = "no" ] && [ "$XPLATFORM_QNX" = "no" ] && [ "$XPLATFORM_ANDROID" = "no" ]; then
|
|
if [ "$CFG_XCB" = "no" ] && [ "$CFG_EGLFS" = "no" ] && [ "$CFG_DIRECTFB" = "no" ] && [ "$CFG_LINUXFB" = "no" ] && [ "$CFG_KMS" = "no" ]; then
|
|
if [ "$QPA_PLATFORM_GUARD" = "yes" ] &&
|
|
( [ "$ORIG_CFG_XCB" = "auto" ] || [ "$ORIG_CFG_EGLFS" = "auto" ] || [ "$ORIG_CFG_DIRECTFB" = "auto" ] || [ "$ORIG_CFG_LINUXFB" = "auto" ] || [ "$ORIG_CFG_KMS" = "auto" ] ); then
|
|
echo "No QPA platform plugin enabled!"
|
|
echo " If you really want to build without a QPA platform plugin you must pass"
|
|
echo " -no-qpa-platform-guard to configure. Doing this will"
|
|
echo " produce a Qt that can not run GUI applications."
|
|
echo " The dependencies needed for xcb to build are listed in"
|
|
echo " src/plugins/platforms/xcb/README"
|
|
exit 1
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
# freetype support
|
|
[ "$XPLATFORM_MINGW" = "yes" ] && [ "$CFG_FREETYPE" = "auto" ] && CFG_FREETYPE=no
|
|
if [ "$CFG_FREETYPE" = "auto" ]; then
|
|
if compileTest unix/freetype "FreeType"; then
|
|
CFG_FREETYPE=system
|
|
else
|
|
CFG_FREETYPE=yes
|
|
fi
|
|
fi
|
|
|
|
# harfbuzz support
|
|
[ "$XPLATFORM_MINGW" = "yes" ] && [ "$CFG_HARFBUZZ" = "auto" ] && CFG_HARFBUZZ=no
|
|
if [ "$CFG_HARFBUZZ" = "auto" ]; then
|
|
if compileTest unix/harfbuzz "HarfBuzz"; then
|
|
CFG_HARFBUZZ=system
|
|
else
|
|
CFG_HARFBUZZ=yes
|
|
fi
|
|
fi
|
|
|
|
if ! compileTest unix/stl "STL" &&
|
|
[ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
|
|
echo "STL functionality check failed! Cannot build Qt with this STL library."
|
|
echo " Turn on verbose messaging (-v) to $0 to see the final report."
|
|
exit 101
|
|
fi
|
|
|
|
|
|
# detect POSIX clock_gettime()
|
|
if [ "$CFG_CLOCK_GETTIME" = "auto" ]; then
|
|
if compileTest unix/clock-gettime "POSIX clock_gettime()"; then
|
|
CFG_CLOCK_GETTIME=yes
|
|
else
|
|
CFG_CLOCK_GETTIME=no
|
|
fi
|
|
fi
|
|
|
|
# detect POSIX monotonic clocks
|
|
if [ "$CFG_CLOCK_GETTIME" = "yes" ] && [ "$CFG_CLOCK_MONOTONIC" = "auto" ]; then
|
|
if compileTest unix/clock-monotonic "POSIX Monotonic Clock"; then
|
|
CFG_CLOCK_MONOTONIC=yes
|
|
else
|
|
CFG_CLOCK_MONOTONIC=no
|
|
fi
|
|
elif [ "$CFG_CLOCK_GETTIME" = "no" ]; then
|
|
CFG_CLOCK_MONOTONIC=no
|
|
fi
|
|
|
|
# detect posix_fallocate
|
|
if [ "$CFG_POSIX_FALLOCATE" = "auto" ]; then
|
|
if compileTest unix/posix_fallocate "posix_fallocate"; then
|
|
CFG_POSIX_FALLOCATE=yes
|
|
else
|
|
CFG_POSIX_FALLOCATE=no
|
|
fi
|
|
fi
|
|
|
|
# detect mremap
|
|
if [ "$CFG_MREMAP" = "auto" ]; then
|
|
if compileTest unix/mremap "mremap"; then
|
|
CFG_MREMAP=yes
|
|
else
|
|
CFG_MREMAP=no
|
|
fi
|
|
fi
|
|
|
|
# find if the platform provides getaddrinfo (ipv6 dns lookups)
|
|
if [ "$CFG_GETADDRINFO" != "no" ]; then
|
|
if compileTest unix/getaddrinfo "getaddrinfo"; then
|
|
CFG_GETADDRINFO=yes
|
|
else
|
|
if [ "$CFG_GETADDRINFO" = "yes" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
|
|
echo "getaddrinfo support cannot be enabled due to functionality tests!"
|
|
echo " Turn on verbose messaging (-v) to $0 to see the final report."
|
|
echo " If you believe this message is in error you may use the continue"
|
|
echo " switch (-continue) to $0 to continue."
|
|
exit 101
|
|
else
|
|
CFG_GETADDRINFO=no
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
# find if the platform provides inotify
|
|
if [ "$CFG_INOTIFY" != "no" ]; then
|
|
if compileTest unix/inotify "inotify"; then
|
|
CFG_INOTIFY=yes
|
|
else
|
|
if [ "$CFG_INOTIFY" = "yes" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
|
|
echo "inotify support cannot be enabled due to functionality tests!"
|
|
echo " Turn on verbose messaging (-v) to $0 to see the final report."
|
|
echo " If you believe this message is in error you may use the continue"
|
|
echo " switch (-continue) to $0 to continue."
|
|
exit 101
|
|
else
|
|
CFG_INOTIFY=no
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
# find if the platform provides eventfd
|
|
if [ "$CFG_EVENTFD" != "no" ]; then
|
|
if compileTest unix/eventfd "eventfd"; then
|
|
CFG_EVENTFD=yes
|
|
else
|
|
if [ "$CFG_EVENTFD" = "yes" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
|
|
echo "eventfd support cannot be enabled due to functionality tests!"
|
|
echo " Turn on verbose messaging (-v) to $0 to see the final report."
|
|
echo " If you believe this message is in error you may use the continue"
|
|
echo " switch (-continue) to $0 to continue."
|
|
exit 101
|
|
else
|
|
CFG_EVENTFD=no
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
# find if the platform provides if_nametoindex (ipv6 interface name support)
|
|
if [ "$CFG_IPV6IFNAME" != "no" ]; then
|
|
if compileTest unix/ipv6ifname "IPv6 interface name"; then
|
|
CFG_IPV6IFNAME=yes
|
|
else
|
|
if [ "$CFG_IPV6IFNAME" = "yes" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
|
|
echo "IPv6 interface name support cannot be enabled due to functionality tests!"
|
|
echo " Turn on verbose messaging (-v) to $0 to see the final report."
|
|
echo " If you believe this message is in error you may use the continue"
|
|
echo " switch (-continue) to $0 to continue."
|
|
exit 101
|
|
else
|
|
CFG_IPV6IFNAME=no
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
# find if the platform provides getifaddrs (network interface enumeration)
|
|
if [ "$CFG_GETIFADDRS" != "no" ]; then
|
|
if compileTest unix/getifaddrs "getifaddrs"; then
|
|
CFG_GETIFADDRS=yes
|
|
else
|
|
if [ "$CFG_GETIFADDRS" = "yes" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
|
|
echo "getifaddrs support cannot be enabled due to functionality tests!"
|
|
echo " Turn on verbose messaging (-v) to $0 to see the final report."
|
|
echo " If you believe this message is in error you may use the continue"
|
|
echo " switch (-continue) to $0 to continue."
|
|
exit 101
|
|
else
|
|
CFG_GETIFADDRS=no
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
# detect OpenSSL
|
|
if [ "$CFG_OPENSSL" != "no" ]; then
|
|
if compileTest unix/openssl "OpenSSL"; then
|
|
if [ "$CFG_OPENSSL" = "auto" ]; then
|
|
CFG_OPENSSL=yes
|
|
fi
|
|
else
|
|
if ( [ "$CFG_OPENSSL" = "yes" ] || [ "$CFG_OPENSSL" = "linked" ] ) && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ] && [ "$XPLATFORM_ANDROID" = "no" ]; then
|
|
echo "OpenSSL support cannot be enabled due to functionality tests!"
|
|
echo " Turn on verbose messaging (-v) to $0 to see the final report."
|
|
echo " If you believe this message is in error you may use the continue"
|
|
echo " switch (-continue) to $0 to continue."
|
|
exit 101
|
|
else
|
|
CFG_OPENSSL=no
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
# detect PCRE
|
|
if [ "$CFG_PCRE" != "qt" ]; then
|
|
if compileTest unix/pcre "PCRE"; then
|
|
CFG_PCRE=system
|
|
else
|
|
if [ "$CFG_PCRE" = "system" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
|
|
echo "PCRE support cannot be enabled due to functionality tests!"
|
|
echo " Turn on verbose messaging (-v) to $0 to see the final report."
|
|
echo " If you believe this message is in error you may use the continue"
|
|
echo " switch (-continue) to $0 to continue."
|
|
exit 101
|
|
else
|
|
CFG_PCRE=qt
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
# detect OpenVG support
|
|
if [ "$CFG_OPENVG" != "no" ]; then
|
|
if compileTest unix/openvg "OpenVG"; then
|
|
if [ "$CFG_OPENVG" = "auto" ]; then
|
|
CFG_OPENVG=yes
|
|
fi
|
|
elif compileTest unix/openvg "OpenVG" -config openvg_on_opengl; then
|
|
if [ "$CFG_OPENVG" = "auto" ]; then
|
|
CFG_OPENVG=yes
|
|
fi
|
|
CFG_OPENVG_ON_OPENGL=yes
|
|
elif compileTest unix/openvg "OpenVG (lc includes)" -config lower_case_includes; then
|
|
if [ "$CFG_OPENVG" = "auto" ]; then
|
|
CFG_OPENVG=yes
|
|
fi
|
|
CFG_OPENVG_LC_INCLUDES=yes
|
|
elif compileTest unix/openvg "OpenVG (lc includes)" -config "openvg_on_opengl lower_case_includes"; then
|
|
if [ "$CFG_OPENVG" = "auto" ]; then
|
|
CFG_OPENVG=yes
|
|
fi
|
|
CFG_OPENVG_LC_INCLUDES=yes
|
|
CFG_OPENVG_ON_OPENGL=yes
|
|
else
|
|
if [ "$CFG_OPENVG" != "auto" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
|
|
echo "$CFG_OPENVG was specified for OpenVG but cannot be enabled due to functionality tests!"
|
|
echo " Turn on verbose messaging (-v) to $0 to see the final report."
|
|
echo " If you believe this message is in error you may use the continue"
|
|
echo " switch (-continue) to $0 to continue."
|
|
exit 101
|
|
else
|
|
CFG_OPENVG=no
|
|
fi
|
|
fi
|
|
if [ "$CFG_OPENVG" = "yes" ] && compileTest unix/shivavg "ShivaVG"; then
|
|
CFG_OPENVG_SHIVA=yes
|
|
fi
|
|
fi
|
|
|
|
if [ "$CFG_ALSA" = "auto" ]; then
|
|
if compileTest unix/alsa "alsa"; then
|
|
CFG_ALSA=yes
|
|
else
|
|
CFG_ALSA=no
|
|
fi
|
|
fi
|
|
|
|
if [ "$CFG_JAVASCRIPTCORE_JIT" = "yes" ] || [ "$CFG_JAVASCRIPTCORE_JIT" = "auto" ]; then
|
|
if [ "$CFG_ARCH" = "arm" ]; then
|
|
compileTest unix/javascriptcore-jit "javascriptcore-jit"
|
|
if [ $? != "0" ]; then
|
|
CFG_JAVASCRIPTCORE_JIT=no
|
|
fi
|
|
else
|
|
case "$XPLATFORM" in
|
|
linux-icc*)
|
|
CFG_JAVASCRIPTCORE_JIT=no
|
|
;;
|
|
esac
|
|
fi
|
|
fi
|
|
|
|
if [ "$CFG_JAVASCRIPTCORE_JIT" = "yes" ]; then
|
|
QMakeVar set JAVASCRIPTCORE_JIT yes
|
|
elif [ "$CFG_JAVASCRIPTCORE_JIT" = "no" ]; then
|
|
QMakeVar set JAVASCRIPTCORE_JIT no
|
|
fi
|
|
|
|
if [ "$CFG_AUDIO_BACKEND" = "auto" ]; then
|
|
CFG_AUDIO_BACKEND=yes
|
|
fi
|
|
|
|
if [ "$CFG_LARGEFILE" != "yes" ] && [ "$XPLATFORM_MINGW" = "yes" ]; then
|
|
echo "Warning: largefile support cannot be disabled for win32."
|
|
CFG_LARGEFILE="yes"
|
|
fi
|
|
|
|
#-------------------------------------------------------------------------------
|
|
# ask for all that hasn't been auto-detected or specified in the arguments
|
|
#-------------------------------------------------------------------------------
|
|
|
|
[ "$CFG_CXX11" = "yes" ] && QT_CONFIG="$QT_CONFIG c++11"
|
|
|
|
if [ "$CFG_SILENT" = "yes" ]; then
|
|
QMAKE_CONFIG="$QMAKE_CONFIG silent"
|
|
fi
|
|
|
|
# disable accessibility
|
|
if [ "$CFG_ACCESSIBILITY" = "no" ]; then
|
|
QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_ACCESSIBILITY"
|
|
else
|
|
QT_CONFIG="$QT_CONFIG accessibility"
|
|
fi
|
|
|
|
# enable egl
|
|
if [ "$CFG_EGL" = "yes" ]; then
|
|
QT_CONFIG="$QT_CONFIG egl"
|
|
else
|
|
QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_EGL"
|
|
fi
|
|
|
|
# enable glx
|
|
if [ "$CFG_GLX" = "yes" ]; then
|
|
QT_CONFIG="$QT_CONFIG glx"
|
|
else
|
|
QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_GLX"
|
|
fi
|
|
|
|
# enable eglfs
|
|
if [ "$CFG_EGLFS" = "yes" ]; then
|
|
QT_CONFIG="$QT_CONFIG eglfs"
|
|
else
|
|
QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_EGLFS"
|
|
fi
|
|
|
|
# enable openvg
|
|
if [ "$CFG_OPENVG" = "no" ]; then
|
|
QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_OPENVG"
|
|
else
|
|
QT_CONFIG="$QT_CONFIG openvg"
|
|
if [ "$CFG_OPENVG_LC_INCLUDES" = "yes" ]; then
|
|
QCONFIG_FLAGS="$QCONFIG_FLAGS QT_LOWER_CASE_VG_INCLUDES"
|
|
fi
|
|
if [ "$CFG_OPENVG_ON_OPENGL" = "yes" ]; then
|
|
QT_CONFIG="$QT_CONFIG openvg_on_opengl"
|
|
fi
|
|
if [ "$CFG_OPENVG_SHIVA" = "yes" ]; then
|
|
QT_CONFIG="$QT_CONFIG shivavg"
|
|
QCONFIG_FLAGS="$QCONFIG_FLAGS QT_SHIVAVG"
|
|
fi
|
|
fi
|
|
|
|
# enable opengl
|
|
if [ "$CFG_OPENGL" = "no" ]; then
|
|
QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_OPENGL"
|
|
else
|
|
QT_CONFIG="$QT_CONFIG opengl"
|
|
fi
|
|
|
|
if [ "$CFG_OPENGL" = "es2" ]; then
|
|
QCONFIG_FLAGS="$QCONFIG_FLAGS QT_OPENGL_ES QT_OPENGL_ES_2"
|
|
QT_CONFIG="$QT_CONFIG opengles2"
|
|
fi
|
|
|
|
if [ "$CFG_SHARED" = "yes" ]; then
|
|
QT_CONFIG="$QT_CONFIG shared"
|
|
QTCONFIG_CONFIG="$QTCONFIG_CONFIG shared"
|
|
elif [ "$CFG_SHARED" = "no" ]; then
|
|
QT_CONFIG="$QT_CONFIG static"
|
|
QTCONFIG_CONFIG="$QTCONFIG_CONFIG static"
|
|
fi
|
|
|
|
#FIXME: qpa is implicit this should all be removed
|
|
QMAKE_CONFIG="$QMAKE_CONFIG qpa"
|
|
QT_CONFIG="$QT_CONFIG qpa"
|
|
QTCONFIG_CONFIG="$QTCONFIG_CONFIG qpa"
|
|
|
|
if [ "$CFG_LARGEFILE" = "yes" ] && [ "$XPLATFORM_MINGW" != "yes" ]; then
|
|
QMAKE_CONFIG="$QMAKE_CONFIG largefile"
|
|
fi
|
|
if [ "$CFG_USE_GNUMAKE" = "yes" ]; then
|
|
QMAKE_CONFIG="$QMAKE_CONFIG GNUmake"
|
|
fi
|
|
[ "$CFG_REDUCE_EXPORTS" = "yes" ] && QT_CONFIG="$QT_CONFIG reduce_exports"
|
|
[ "$CFG_STACK_PROTECTOR_STRONG" = "yes" ] && QT_CONFIG="$QT_CONFIG stack-protector-strong"
|
|
[ "$CFG_REDUCE_RELOCATIONS" = "yes" ] && QT_CONFIG="$QT_CONFIG reduce_relocations"
|
|
[ "$CFG_STRIP" = "no" ] && QMAKE_CONFIG="$QMAKE_CONFIG nostrip"
|
|
[ "$CFG_PRECOMPILE" = "yes" ] && QMAKE_CONFIG="$QMAKE_CONFIG precompile_header"
|
|
if [ "$CFG_SEPARATE_DEBUG_INFO" = "yes" ]; then
|
|
QMakeVar add QMAKE_CFLAGS -g
|
|
QMakeVar add QMAKE_CXXFLAGS -g
|
|
QT_CONFIG="$QT_CONFIG separate_debug_info"
|
|
fi
|
|
if [ "$CFG_SEPARATE_DEBUG_INFO_NOCOPY" = "yes" ] ; then
|
|
QT_CONFIG="$QT_CONFIG separate_debug_info_nocopy"
|
|
fi
|
|
[ "$CFG_SSE2" = "yes" ] && QMAKE_CONFIG="$QMAKE_CONFIG sse2"
|
|
[ "$CFG_SSE3" = "yes" ] && QMAKE_CONFIG="$QMAKE_CONFIG sse3"
|
|
[ "$CFG_SSSE3" = "yes" ] && QMAKE_CONFIG="$QMAKE_CONFIG ssse3"
|
|
[ "$CFG_SSE4_1" = "yes" ] && QMAKE_CONFIG="$QMAKE_CONFIG sse4_1"
|
|
[ "$CFG_SSE4_2" = "yes" ] && QMAKE_CONFIG="$QMAKE_CONFIG sse4_2"
|
|
[ "$CFG_AVX" = "yes" ] && QMAKE_CONFIG="$QMAKE_CONFIG avx"
|
|
[ "$CFG_AVX2" = "yes" ] && QMAKE_CONFIG="$QMAKE_CONFIG avx2"
|
|
[ "$CFG_IWMMXT" = "yes" ] && QMAKE_CONFIG="$QMAKE_CONFIG iwmmxt"
|
|
[ "$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_LIBJPEG" = "no" ]; then
|
|
CFG_JPEG="no"
|
|
elif [ "$CFG_LIBJPEG" = "system" ]; then
|
|
QT_CONFIG="$QT_CONFIG system-jpeg"
|
|
fi
|
|
if [ "$CFG_JPEG" = "no" ]; then
|
|
QT_CONFIG="$QT_CONFIG no-jpeg"
|
|
elif [ "$CFG_JPEG" = "yes" ]; then
|
|
QT_CONFIG="$QT_CONFIG jpeg"
|
|
fi
|
|
if [ "$CFG_LIBPNG" = "no" ]; then
|
|
CFG_PNG="no"
|
|
fi
|
|
if [ "$CFG_LIBPNG" = "system" ]; then
|
|
QT_CONFIG="$QT_CONFIG system-png"
|
|
fi
|
|
if [ "$CFG_PNG" = "no" ]; then
|
|
QT_CONFIG="$QT_CONFIG no-png"
|
|
elif [ "$CFG_PNG" = "yes" ]; then
|
|
QT_CONFIG="$QT_CONFIG png"
|
|
fi
|
|
if [ "$CFG_GIF" = "no" ]; then
|
|
QT_CONFIG="$QT_CONFIG no-gif"
|
|
elif [ "$CFG_GIF" = "yes" ]; then
|
|
QT_CONFIG="$QT_CONFIG gif"
|
|
fi
|
|
if [ "$CFG_FREETYPE" = "no" ]; then
|
|
QT_CONFIG="$QT_CONFIG no-freetype"
|
|
QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_FREETYPE"
|
|
elif [ "$CFG_FREETYPE" = "system" ]; then
|
|
QT_CONFIG="$QT_CONFIG system-freetype"
|
|
else
|
|
QT_CONFIG="$QT_CONFIG freetype"
|
|
fi
|
|
if [ "$CFG_HARFBUZZ" = "no" ]; then
|
|
QT_CONFIG="$QT_CONFIG no-harfbuzz"
|
|
QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_HARFBUZZ"
|
|
elif [ "$CFG_HARFBUZZ" = "system" ]; then
|
|
QT_CONFIG="$QT_CONFIG system-harfbuzz"
|
|
else
|
|
QT_CONFIG="$QT_CONFIG harfbuzz"
|
|
fi
|
|
if [ "$CFG_GUI" = "auto" ]; then
|
|
CFG_GUI="yes"
|
|
fi
|
|
if [ "$CFG_GUI" = "no" ]; then
|
|
QT_CONFIG="$QT_CONFIG no-gui"
|
|
CFG_WIDGETS="no"
|
|
fi
|
|
if [ "$CFG_WIDGETS" = "no" ]; then
|
|
QT_CONFIG="$QT_CONFIG no-widgets"
|
|
QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_WIDGETS"
|
|
fi
|
|
|
|
if [ "$XPLATFORM_MAC" = "yes" ]; then
|
|
#On Mac we implicitly link against libz, so we
|
|
#never use the 3rdparty stuff.
|
|
[ "$CFG_ZLIB" = "yes" ] && CFG_ZLIB="system"
|
|
fi
|
|
if [ "$CFG_ZLIB" = "yes" ]; then
|
|
QT_CONFIG="$QT_CONFIG zlib"
|
|
elif [ "$CFG_ZLIB" = "system" ]; then
|
|
QT_CONFIG="$QT_CONFIG system-zlib"
|
|
fi
|
|
|
|
[ "$CFG_NIS" = "yes" ] && QT_CONFIG="$QT_CONFIG nis"
|
|
[ "$CFG_CUPS" = "yes" ] && QT_CONFIG="$QT_CONFIG cups"
|
|
[ "$CFG_ICONV" = "yes" ] && QT_CONFIG="$QT_CONFIG iconv"
|
|
[ "$CFG_ICONV" = "sun" ] && QT_CONFIG="$QT_CONFIG sun-libiconv"
|
|
[ "$CFG_ICONV" = "gnu" ] && QT_CONFIG="$QT_CONFIG gnu-libiconv"
|
|
[ "$CFG_GLIB" = "yes" ] && QT_CONFIG="$QT_CONFIG glib"
|
|
[ "$CFG_DBUS" = "yes" ] && QT_CONFIG="$QT_CONFIG dbus"
|
|
[ "$CFG_DBUS" = "linked" ] && QT_CONFIG="$QT_CONFIG dbus dbus-linked"
|
|
[ "$CFG_OPENSSL" = "yes" ] && QT_CONFIG="$QT_CONFIG openssl"
|
|
[ "$CFG_OPENSSL" = "linked" ] && QT_CONFIG="$QT_CONFIG openssl-linked"
|
|
[ "$CFG_XCB" != "no" ] && QT_CONFIG="$QT_CONFIG xcb"
|
|
[ "$CFG_XINPUT2" = "yes" ] && QT_CONFIG="$QT_CONFIG xinput2"
|
|
[ "$CFG_SYSTEM_PROXIES" = "yes" ] && QT_CONFIG="$QT_CONFIG system-proxies"
|
|
[ "$CFG_DIRECTWRITE" = "yes" ] && QT_CONFIG="$QT_CONFIG directwrite"
|
|
|
|
[ '!' -z "$DEFINES" ] && QMakeVar add DEFINES "$DEFINES"
|
|
[ '!' -z "$L_FLAGS" ] && QMakeVar add LIBS "$L_FLAGS"
|
|
|
|
if [ "$XPLATFORM_MAC" = "yes" ] && [ "$QT_CROSS_COMPILE" = "no" ]; then
|
|
if [ "$CFG_RPATH" = "yes" ]; then
|
|
QMAKE_CONFIG="$QMAKE_CONFIG absolute_library_soname"
|
|
fi
|
|
elif [ -z "`getXQMakeConf 'QMAKE_(LFLAGS_)?RPATH'`" ]; then
|
|
if [ -n "$RPATH_FLAGS" ]; then
|
|
echo
|
|
echo "ERROR: -R cannot be used on this platform as \$QMAKE_LFLAGS_RPATH is"
|
|
echo " undefined."
|
|
echo
|
|
exit 1
|
|
elif [ "$CFG_RPATH" = "yes" ]; then
|
|
RPATH_MESSAGE=" NOTE: This platform does not support runtime library paths, using -no-rpath."
|
|
CFG_RPATH=no
|
|
fi
|
|
else
|
|
if [ -n "$RPATH_FLAGS" ]; then
|
|
# add the user defined rpaths
|
|
QMakeVar add QMAKE_RPATHDIR "$RPATH_FLAGS"
|
|
fi
|
|
fi
|
|
if [ "$CFG_RPATH" = "yes" ]; then
|
|
QT_CONFIG="$QT_CONFIG rpath"
|
|
fi
|
|
|
|
if [ '!' -z "$I_FLAGS" ]; then
|
|
# add the user define include paths
|
|
QMakeVar add QMAKE_CFLAGS "$I_FLAGS"
|
|
QMakeVar add QMAKE_CXXFLAGS "$I_FLAGS"
|
|
fi
|
|
|
|
if [ '!' -z "$W_FLAGS" ]; then
|
|
# add the user defined warning flags
|
|
QMakeVar add QMAKE_CFLAGS_WARN_ON "$W_FLAGS"
|
|
QMakeVar add QMAKE_CXXFLAGS_WARN_ON "$W_FLAGS"
|
|
QMakeVar add QMAKE_OBJECTIVE_CFLAGS_WARN_ON "$W_FLAGS"
|
|
fi
|
|
|
|
if [ "$XPLATFORM_MINGW" = "yes" ]; then
|
|
# mkspecs/features/win32/default_pre.prf sets "no-rtti".
|
|
# Follow default behavior of configure.exe by overriding with "rtti".
|
|
QTCONFIG_CONFIG="$QTCONFIG_CONFIG rtti"
|
|
fi
|
|
|
|
if [ "$CFG_ALSA" = "yes" ]; then
|
|
QT_CONFIG="$QT_CONFIG alsa"
|
|
fi
|
|
|
|
if [ "$CFG_PULSEAUDIO" = "yes" ]; then
|
|
QT_CONFIG="$QT_CONFIG pulseaudio"
|
|
fi
|
|
|
|
if [ "$CFG_COREWLAN" = "yes" ]; then
|
|
QT_CONFIG="$QT_CONFIG corewlan"
|
|
fi
|
|
|
|
if [ "$CFG_ICU" = "yes" ]; then
|
|
QT_CONFIG="$QT_CONFIG icu"
|
|
fi
|
|
|
|
if [ "$CFG_FORCE_ASSERTS" = "yes" ]; then
|
|
QT_CONFIG="$QT_CONFIG force_asserts"
|
|
fi
|
|
|
|
if [ "$CFG_PCRE" = "qt" ]; then
|
|
QMAKE_CONFIG="$QMAKE_CONFIG pcre"
|
|
fi
|
|
|
|
#
|
|
# Some Qt modules are too advanced in C++ for some old compilers
|
|
# Detect here the platforms where they are known to work.
|
|
#
|
|
# See Qt documentation for more information on which features are
|
|
# supported and on which compilers.
|
|
#
|
|
canBuildQtConcurrent="yes"
|
|
|
|
case "$XPLATFORM" in
|
|
hpux-g++*)
|
|
# PA-RISC's assembly is too limited
|
|
# gcc 3.4 on that platform can't build QtXmlPatterns
|
|
# the assembly it generates cannot be compiled
|
|
|
|
# Check gcc's version
|
|
case "$(${QMAKE_CONF_COMPILER} -dumpversion)" in
|
|
4*)
|
|
;;
|
|
3.4*)
|
|
canBuildQtXmlPatterns="no"
|
|
;;
|
|
*)
|
|
canBuildWebKit="no"
|
|
canBuildQtXmlPatterns="no"
|
|
;;
|
|
esac
|
|
;;
|
|
unsupported/vxworks-*-g++*)
|
|
canBuildWebKit="no"
|
|
;;
|
|
unsupported/vxworks-*-dcc*)
|
|
canBuildWebKit="no"
|
|
canBuildQtXmlPatterns="no"
|
|
;;
|
|
*-g++*)
|
|
# Check gcc's version
|
|
case "$(${QMAKE_CONF_COMPILER} -dumpversion)" in
|
|
4*|3.4*)
|
|
;;
|
|
3.3*)
|
|
canBuildWebKit="no"
|
|
;;
|
|
*)
|
|
canBuildWebKit="no"
|
|
canBuildQtXmlPatterns="no"
|
|
;;
|
|
esac
|
|
;;
|
|
solaris-cc*)
|
|
# Check the compiler version
|
|
case `${QMAKE_CONF_COMPILER} -V 2>&1 | $AWK '{print $4}'` in
|
|
5.[012345678])
|
|
canBuildWebKit="no"
|
|
canBuildQtXmlPatterns="no"
|
|
canBuildQtConcurrent="no"
|
|
;;
|
|
5.*)
|
|
canBuildWebKit="no"
|
|
canBuildQtConcurrent="no"
|
|
;;
|
|
esac
|
|
;;
|
|
hpux-acc*)
|
|
canBuildWebKit="no"
|
|
canBuildQtXmlPatterns="no"
|
|
canBuildQtConcurrent="no"
|
|
;;
|
|
hpuxi-acc*)
|
|
canBuildWebKit="no"
|
|
;;
|
|
aix-xlc*)
|
|
# Get the xlC version
|
|
cat > xlcver.c <<EOF
|
|
#include <stdio.h>
|
|
int main()
|
|
{
|
|
printf("%d.%d\n", __xlC__ >> 8, __xlC__ & 0xFF);
|
|
return 0;
|
|
}
|
|
EOF
|
|
xlcver=
|
|
if ${QMAKE_CONF_COMPILER} -o xlcver xlcver.c >/dev/null 2>/dev/null; then
|
|
xlcver=`./xlcver 2>/dev/null`
|
|
rm -f ./xlcver
|
|
fi
|
|
if [ "$OPT_VERBOSE" = "yes" ]; then
|
|
if [ -n "$xlcver" ]; then
|
|
echo Found IBM xlC version: $xlcver.
|
|
else
|
|
echo Could not determine IBM xlC version, assuming oldest supported.
|
|
fi
|
|
fi
|
|
|
|
case "$xlcver" in
|
|
[123456].*)
|
|
canBuildWebKit="no"
|
|
canBuildQtXmlPatterns="no"
|
|
canBuildQtConcurrent="no"
|
|
;;
|
|
*)
|
|
canBuildWebKit="no"
|
|
canBuildQtConcurrent="no"
|
|
;;
|
|
esac
|
|
;;
|
|
irix-cc*)
|
|
canBuildWebKit="no"
|
|
canBuildQtConcurrent="no"
|
|
;;
|
|
esac
|
|
|
|
if [ "$CFG_GUI" = "no" ]; then
|
|
# WebKit requires Qt GUI
|
|
canBuildWebKit="no"
|
|
fi
|
|
|
|
if [ "$CFG_SHARED" = "no" ]; then
|
|
echo
|
|
echo "WARNING: Using static linking will disable the WebKit module."
|
|
echo
|
|
canBuildWebKit="no"
|
|
fi
|
|
|
|
CFG_CONCURRENT="yes"
|
|
if [ "$canBuildQtConcurrent" = "no" ]; then
|
|
QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_CONCURRENT"
|
|
CFG_CONCURRENT="no"
|
|
else
|
|
QT_CONFIG="$QT_CONFIG concurrent"
|
|
fi
|
|
|
|
# ### Vestige
|
|
if [ "$CFG_AUDIO_BACKEND" = "yes" ]; then
|
|
QT_CONFIG="$QT_CONFIG audio-backend"
|
|
fi
|
|
|
|
# ### Vestige
|
|
if [ "$CFG_WEBKIT" = "debug" ]; then
|
|
QMAKE_CONFIG="$QMAKE_CONFIG webkit-debug"
|
|
fi
|
|
|
|
# ### Vestige
|
|
if [ "$CFG_QML_DEBUG" = "no" ]; then
|
|
QCONFIG_FLAGS="$QCONFIG_FLAGS QT_QML_NO_DEBUGGER"
|
|
fi
|
|
|
|
case "$QMAKE_CONF_COMPILER" in
|
|
*clang*)
|
|
# Clang
|
|
COMPILER_VERSION=`${QMAKE_CONF_COMPILER} -v 2>&1 | sed -n -E '
|
|
/^Apple (clang|LLVM) version /{s///; s/^([0-9]*)\.([0-9]*).*$/QT_APPLE_CLANG_MAJOR_VERSION=\1; QT_APPLE_CLANG_MINOR_VERSION=\2/;p;q;}
|
|
/^clang version /{s///; s/^([0-9]*)\.([0-9]*).*$/QT_CLANG_MAJOR_VERSION=\1; QT_CLANG_MINOR_VERSION=\2/;p;q;}'`
|
|
eval "$COMPILER_VERSION"
|
|
;;
|
|
*icpc)
|
|
# Intel CC
|
|
COMPILER_VERSION=`${QMAKE_CONF_COMPILER} -v 2>&1 | sed -n '
|
|
s/icpc version \([0-9]*\)\.\([0-9]*\)\.\([0-9]*\) .*$/QT_ICC_MAJOR_VERSION=\1; QT_ICC_MINOR_VERSION=\2; QT_ICC_PATCH_VERSION=\3/p'`
|
|
eval "$COMPILER_VERSION"
|
|
;;
|
|
*g++*)
|
|
# GNU C++
|
|
COMPILER_VERSION=`${QMAKE_CONF_COMPILER} -dumpversion 2>/dev/null`
|
|
|
|
case "$COMPILER_VERSION" in
|
|
*.*.*)
|
|
QT_GCC_MAJOR_VERSION=`echo $COMPILER_VERSION | sed 's,^\([0-9]*\)\.\([0-9]*\)\.\([0-9]*\).*,\1,'`
|
|
QT_GCC_MINOR_VERSION=`echo $COMPILER_VERSION | sed 's,^\([0-9]*\)\.\([0-9]*\)\.\([0-9]*\).*,\2,'`
|
|
QT_GCC_PATCH_VERSION=`echo $COMPILER_VERSION | sed 's,^\([0-9]*\)\.\([0-9]*\)\.\([0-9]*\).*,\3,'`
|
|
;;
|
|
*.*)
|
|
QT_GCC_MAJOR_VERSION=`echo $COMPILER_VERSION | sed 's,^\([0-9]*\)\.\([0-9]*\).*,\1,'`
|
|
QT_GCC_MINOR_VERSION=`echo $COMPILER_VERSION | sed 's,^\([0-9]*\)\.\([0-9]*\).*,\2,'`
|
|
QT_GCC_PATCH_VERSION=0
|
|
;;
|
|
esac
|
|
|
|
;;
|
|
*)
|
|
#
|
|
;;
|
|
esac
|
|
|
|
#-------------------------------------------------------------------------------
|
|
# part of configuration information goes into qconfig.h
|
|
#-------------------------------------------------------------------------------
|
|
|
|
case "$CFG_QCONFIG" in
|
|
full)
|
|
echo "/* Everything */" >"$outpath/src/corelib/global/qconfig.h.new"
|
|
;;
|
|
*)
|
|
tmpconfig="$outpath/src/corelib/global/qconfig.h.new"
|
|
echo "#ifndef QT_BOOTSTRAPPED" >"$tmpconfig"
|
|
cat "$CFG_QCONFIG_PATH" >>"$tmpconfig"
|
|
echo "#endif" >>"$tmpconfig"
|
|
;;
|
|
esac
|
|
|
|
cat >>"$outpath/src/corelib/global/qconfig.h.new" <<EOF
|
|
|
|
/* Qt Edition */
|
|
#ifndef QT_EDITION
|
|
# define QT_EDITION $QT_EDITION
|
|
#endif
|
|
EOF
|
|
|
|
echo '/* Compile time features */' >>"$outpath/src/corelib/global/qconfig.h.new"
|
|
[ '!' -z "$LicenseKeyExt" ] && echo "#define QT_PRODUCT_LICENSEKEY \"$LicenseKeyExt\"" >>"$outpath/src/corelib/global/qconfig.h.new"
|
|
|
|
if [ "$CFG_SHARED" = "no" ]; then
|
|
cat >>"$outpath/src/corelib/global/qconfig.h.new" <<EOF
|
|
/* Qt was configured for a static build */
|
|
#if !defined(QT_SHARED) && !defined(QT_STATIC)
|
|
# define QT_STATIC
|
|
#endif
|
|
|
|
EOF
|
|
fi
|
|
|
|
if [ "$CFG_LARGEFILE" = "yes" ] && [ "$XPLATFORM_MINGW" != "yes" ]; then
|
|
echo "#define QT_LARGEFILE_SUPPORT 64" >>"$outpath/src/corelib/global/qconfig.h.new"
|
|
fi
|
|
|
|
if [ "$CFG_QREAL" != double ]; then
|
|
echo "#define QT_COORD_TYPE $CFG_QREAL" >>"$outpath/src/corelib/global/qconfig.h.new"
|
|
fi
|
|
|
|
if [ "$CFG_FRAMEWORK" = "yes" ]; then
|
|
echo "#define QT_MAC_FRAMEWORK_BUILD" >>"$outpath/src/corelib/global/qconfig.h.new"
|
|
fi
|
|
|
|
if [ "$XPLATFORM_MAC" = "yes" ]; then
|
|
cat >>"$outpath/src/corelib/global/qconfig.h.new" <<EOF
|
|
#if defined(__LP64__)
|
|
# define QT_POINTER_SIZE 8
|
|
#else
|
|
# define QT_POINTER_SIZE 4
|
|
#endif
|
|
EOF
|
|
else
|
|
"$unixtests/ptrsize.test" "$XQMAKESPEC" $OPT_VERBOSE "$relpath" "$outpath"
|
|
echo "#define QT_POINTER_SIZE $?" >>"$outpath/src/corelib/global/qconfig.h.new"
|
|
fi
|
|
|
|
#REDUCE_RELOCATIONS is a elf/unix only thing, so not in windows configure.exe
|
|
if [ "$CFG_REDUCE_RELOCATIONS" = "yes" ]; then
|
|
echo "#define QT_REDUCE_RELOCATIONS" >>"$outpath/src/corelib/global/qconfig.h.new"
|
|
fi
|
|
|
|
# Add compiler sub-architecture support
|
|
echo "" >>"$outpath/src/corelib/global/qconfig.h.new"
|
|
echo "// Compiler sub-arch support" >>"$outpath/src/corelib/global/qconfig.h.new"
|
|
for SUBARCH in SSE2 SSE3 SSSE3 SSE4_1 SSE4_2 AVX AVX2 \
|
|
IWMMXT NEON \
|
|
MIPS_DSP MIPS_DSPR2; do
|
|
eval "VAL=\$CFG_$SUBARCH"
|
|
case "$VAL" in
|
|
yes)
|
|
echo "#define QT_COMPILER_SUPPORTS_$SUBARCH" \
|
|
>>"$outpath/src/corelib/global/qconfig.h.new"
|
|
;;
|
|
esac
|
|
done
|
|
|
|
echo "" >>"$outpath/src/corelib/global/qconfig.h.new"
|
|
|
|
if [ "$CFG_DEV" = "yes" ]; then
|
|
echo "#define QT_BUILD_INTERNAL" >>"$outpath/src/corelib/global/qconfig.h.new"
|
|
fi
|
|
|
|
# Add QPA to config.h
|
|
QCONFIG_FLAGS="$QCONFIG_FLAGS"
|
|
|
|
if [ "${CFG_USE_FLOATMATH}" = "yes" ]; then
|
|
QCONFIG_FLAGS="${QCONFIG_FLAGS} QT_USE_MATH_H_FLOATS"
|
|
fi
|
|
|
|
# Add turned on SQL drivers
|
|
for DRIVER in $CFG_SQL_AVAILABLE; do
|
|
eval "VAL=\$CFG_SQL_$DRIVER"
|
|
case "$VAL" in
|
|
qt)
|
|
ONDRIVER=`echo $DRIVER | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
|
|
QCONFIG_FLAGS="$QCONFIG_FLAGS QT_SQL_$ONDRIVER"
|
|
SQL_DRIVERS="$SQL_DRIVERS $DRIVER"
|
|
;;
|
|
plugin)
|
|
SQL_PLUGINS="$SQL_PLUGINS $DRIVER"
|
|
;;
|
|
esac
|
|
done
|
|
|
|
QMakeVar set sql-drivers "$SQL_DRIVERS"
|
|
QMakeVar set sql-plugins "$SQL_PLUGINS"
|
|
|
|
# Add other configuration options to the qconfig.h file
|
|
[ "$CFG_GIF" = "yes" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_BUILTIN_GIF_READER=1"
|
|
[ "$CFG_PNG" != "yes" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_IMAGEFORMAT_PNG"
|
|
[ "$CFG_JPEG" != "yes" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_IMAGEFORMAT_JPEG"
|
|
[ "$CFG_ZLIB" != "yes" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_ZLIB"
|
|
[ "$CFG_DBUS" = "no" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_DBUS"
|
|
|
|
# X11/Unix/Mac only configs
|
|
[ "$CFG_CUPS" = "no" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_CUPS"
|
|
[ "$CFG_ICONV" = "no" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_ICONV"
|
|
[ "$CFG_GLIB" != "yes" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_GLIB"
|
|
[ "$CFG_QGTKSTYLE" != "yes" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_STYLE_GTK"
|
|
[ "$CFG_CLOCK_MONOTONIC" = "no" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_CLOCK_MONOTONIC"
|
|
[ "$CFG_POSIX_FALLOCATE" = "no" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_POSIX_FALLOCATE"
|
|
[ "$CFG_MREMAP" = "no" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_MREMAP"
|
|
[ "$CFG_GETADDRINFO" = "no" ]&& QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_GETADDRINFO"
|
|
[ "$CFG_IPV6IFNAME" = "no" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_IPV6IFNAME"
|
|
[ "$CFG_GETIFADDRS" = "no" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_GETIFADDRS"
|
|
[ "$CFG_INOTIFY" = "no" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_INOTIFY"
|
|
[ "$CFG_EVENTFD" = "no" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_EVENTFD"
|
|
[ "$CFG_NIS" = "no" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_NIS"
|
|
[ "$CFG_OPENSSL" = "no" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_OPENSSL QT_NO_SSL"
|
|
[ "$CFG_OPENSSL" = "linked" ]&& QCONFIG_FLAGS="$QCONFIG_FLAGS QT_LINKED_OPENSSL"
|
|
|
|
[ "$CFG_SM" = "no" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_SESSIONMANAGER"
|
|
[ "$CFG_XCURSOR" = "no" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_XCURSOR"
|
|
[ "$CFG_XFIXES" = "no" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_XFIXES"
|
|
[ "$CFG_FONTCONFIG" = "no" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_FONTCONFIG"
|
|
[ "$CFG_XINERAMA" = "no" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_XINERAMA"
|
|
[ "$CFG_XKB" = "no" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_XKB"
|
|
[ "$CFG_XRANDR" = "no" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_XRANDR"
|
|
[ "$CFG_XRENDER" = "no" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_XRENDER"
|
|
[ "$CFG_MITSHM" = "no" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_MITSHM"
|
|
[ "$CFG_XSHAPE" = "no" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_SHAPE"
|
|
[ "$CFG_XVIDEO" = "no" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_XVIDEO"
|
|
[ "$CFG_XSYNC" = "no" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_XSYNC"
|
|
[ "$CFG_XINPUT" = "no" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_XINPUT QT_NO_TABLET"
|
|
|
|
[ "$CFG_XCURSOR" = "runtime" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_RUNTIME_XCURSOR"
|
|
[ "$CFG_XINERAMA" = "runtime" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_RUNTIME_XINERAMA"
|
|
[ "$CFG_XFIXES" = "runtime" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_RUNTIME_XFIXES"
|
|
[ "$CFG_XRANDR" = "runtime" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_RUNTIME_XRANDR"
|
|
[ "$CFG_XINPUT" = "runtime" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_RUNTIME_XINPUT"
|
|
[ "$CFG_ALSA" = "no" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_ALSA"
|
|
[ "$CFG_PULSEAUDIO" = "no" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_PULSEAUDIO"
|
|
[ "$CFG_COREWLAN" = "no" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_COREWLAN"
|
|
|
|
# sort QCONFIG_FLAGS for neatness if we can
|
|
[ '!' -z "$AWK" ] && QCONFIG_FLAGS=`echo $QCONFIG_FLAGS | $AWK '{ gsub(" ", "\n"); print }' | sort | uniq`
|
|
QCONFIG_FLAGS=`echo $QCONFIG_FLAGS`
|
|
|
|
if [ -n "$QCONFIG_FLAGS" ]; then
|
|
cat >>"$outpath/src/corelib/global/qconfig.h.new" << EOF
|
|
#ifndef QT_BOOTSTRAPPED
|
|
|
|
EOF
|
|
for cfg in $QCONFIG_FLAGS; do
|
|
cfgd=`echo $cfg | sed 's/=.*$//'` # trim pushed 'Foo=Bar' defines
|
|
cfg=`echo $cfg | sed 's/=/ /'` # turn first '=' into a space
|
|
# figure out define logic, so we can output the correct
|
|
# ifdefs to override the global defines in a project
|
|
cfgdNeg=
|
|
if [ true ] && echo "$cfgd" | grep 'QT_NO_' >/dev/null 2>&1; then
|
|
# QT_NO_option can be forcefully turned on by QT_option
|
|
cfgdNeg=`echo $cfgd | sed "s,QT_NO_,QT_,"`
|
|
elif [ true ] && echo "$cfgd" | grep 'QT_' >/dev/null 2>&1; then
|
|
# QT_option can be forcefully turned off by QT_NO_option
|
|
cfgdNeg=`echo $cfgd | sed "s,QT_,QT_NO_,"`
|
|
fi
|
|
|
|
if [ -z $cfgdNeg ]; then
|
|
cat >>"$outpath/src/corelib/global/qconfig.h.new" << EOF
|
|
#ifndef $cfgd
|
|
# define $cfg
|
|
#endif
|
|
|
|
EOF
|
|
else
|
|
cat >>"$outpath/src/corelib/global/qconfig.h.new" << EOF
|
|
#if defined($cfgd) && defined($cfgdNeg)
|
|
# undef $cfgd
|
|
#elif !defined($cfgd) && !defined($cfgdNeg)
|
|
# define $cfg
|
|
#endif
|
|
|
|
EOF
|
|
fi
|
|
done
|
|
cat >>"$outpath/src/corelib/global/qconfig.h.new" << EOF
|
|
#endif // QT_BOOTSTRAPPED
|
|
|
|
EOF
|
|
fi
|
|
|
|
if [ "$CFG_REDUCE_EXPORTS" = "yes" ]; then
|
|
cat >>"$outpath/src/corelib/global/qconfig.h.new" << EOF
|
|
#define QT_VISIBILITY_AVAILABLE
|
|
|
|
EOF
|
|
fi
|
|
|
|
if [ -n "$QT_LIBINFIX" ]; then
|
|
cat >>"$outpath/src/corelib/global/qconfig.h.new" << EOF
|
|
#define QT_LIBINFIX "$QT_LIBINFIX"
|
|
|
|
EOF
|
|
fi
|
|
|
|
echo "#define QT_QPA_DEFAULT_PLATFORM_NAME \"$QT_QPA_DEFAULT_PLATFORM\"" >>"$outpath/src/corelib/global/qconfig.h.new"
|
|
|
|
# avoid unecessary rebuilds by copying only if qconfig.h has changed
|
|
if cmp -s "$outpath/src/corelib/global/qconfig.h" "$outpath/src/corelib/global/qconfig.h.new"; then
|
|
rm -f "$outpath/src/corelib/global/qconfig.h.new"
|
|
else
|
|
mv -f "$outpath/src/corelib/global/qconfig.h.new" "$outpath/src/corelib/global/qconfig.h"
|
|
fi
|
|
|
|
# create a forwarding header
|
|
mkdir -p "$outpath/include/QtCore" || exit
|
|
echo '#include "../../src/corelib/global/qconfig.h"' > $outpath/include/QtCore/qconfig.h.new
|
|
if cmp -s "$outpath/include/QtCore/qconfig.h.new" "$outpath/include/QtCore/qconfig.h"; then
|
|
rm -f "$outpath/include/QtCore/qconfig.h.new"
|
|
else
|
|
mv "$outpath/include/QtCore/qconfig.h.new" "$outpath/include/QtCore/qconfig.h" || exit
|
|
fi
|
|
|
|
# create a camelcase forwarding header
|
|
echo '#include "qconfig.h"' > $outpath/include/QtCore/QtConfig.new
|
|
if cmp -s "$outpath/include/QtCore/QtConfig.new" "$outpath/include/QtCore/QtConfig"; then
|
|
rm -f "$outpath/include/QtCore/QtConfig.new"
|
|
else
|
|
mv "$outpath/include/QtCore/QtConfig.new" "$outpath/include/QtCore/QtConfig" || exit
|
|
fi
|
|
|
|
#-------------------------------------------------------------------------------
|
|
# save configuration into qconfig.pri
|
|
#-------------------------------------------------------------------------------
|
|
QTCONFIG="$outpath/mkspecs/qconfig.pri"
|
|
QTCONFIG_CONFIG="$QTCONFIG_CONFIG no_mocdepend"
|
|
[ -f "$QTCONFIG.tmp" ] && rm -f "$QTCONFIG.tmp"
|
|
if [ "$CFG_DEBUG" = "yes" ]; then
|
|
QTCONFIG_CONFIG="$QTCONFIG_CONFIG debug"
|
|
if [ "$CFG_DEBUG_RELEASE" = "yes" ]; then
|
|
QT_CONFIG="$QT_CONFIG release"
|
|
fi
|
|
QT_CONFIG="$QT_CONFIG debug"
|
|
elif [ "$CFG_DEBUG" = "no" ]; then
|
|
QTCONFIG_CONFIG="$QTCONFIG_CONFIG release"
|
|
if [ "$CFG_DEBUG_RELEASE" = "yes" ]; then
|
|
QT_CONFIG="$QT_CONFIG debug"
|
|
fi
|
|
QT_CONFIG="$QT_CONFIG release"
|
|
fi
|
|
if [ "$CFG_FRAMEWORK" = "no" ]; then
|
|
QTCONFIG_CONFIG="$QTCONFIG_CONFIG qt_no_framework"
|
|
else
|
|
QT_CONFIG="$QT_CONFIG qt_framework"
|
|
QTCONFIG_CONFIG="$QTCONFIG_CONFIG qt_framework"
|
|
fi
|
|
if [ "$CFG_DEV" = "yes" ]; then
|
|
QT_CONFIG="$QT_CONFIG private_tests"
|
|
if [ "$CFG_WERROR" != "no" ]; then
|
|
QMAKE_CONFIG="$QMAKE_CONFIG warnings_are_errors"
|
|
fi
|
|
elif [ "$CFG_WERROR" = "yes" ]; then
|
|
QMAKE_CONFIG="$QMAKE_CONFIG warnings_are_errors"
|
|
fi
|
|
|
|
cat >>"$QTCONFIG.tmp" <<EOF
|
|
#configuration
|
|
CONFIG += $QTCONFIG_CONFIG
|
|
host_build {
|
|
QT_ARCH = $CFG_HOST_ARCH
|
|
QT_TARGET_ARCH = $CFG_ARCH
|
|
} else {
|
|
QT_ARCH = $CFG_ARCH
|
|
QMAKE_DEFAULT_LIBDIRS = `shellQuoteLines "$DEFAULT_LIBDIRS"`
|
|
QMAKE_DEFAULT_INCDIRS = `shellQuoteLines "$DEFAULT_INCDIRS"`
|
|
}
|
|
QT_EDITION = $Edition
|
|
QT_CONFIG += $QT_CONFIG
|
|
|
|
#versioning
|
|
QT_VERSION = $QT_VERSION
|
|
QT_MAJOR_VERSION = $QT_MAJOR_VERSION
|
|
QT_MINOR_VERSION = $QT_MINOR_VERSION
|
|
QT_PATCH_VERSION = $QT_PATCH_VERSION
|
|
|
|
#namespaces
|
|
QT_LIBINFIX = $QT_LIBINFIX
|
|
QT_NAMESPACE = $QT_NAMESPACE
|
|
|
|
EOF
|
|
|
|
if [ "$CFG_SHARED" = "no" ]; then
|
|
echo "QT_DEFAULT_QPA_PLUGIN = q$QT_QPA_DEFAULT_PLATFORM" >> "$QTCONFIG.tmp"
|
|
echo >> "$QTCONFIG.tmp"
|
|
fi
|
|
|
|
if [ -n "$PKG_CONFIG_SYSROOT_DIR" ] || [ -n "$PKG_CONFIG_LIBDIR" ]; then
|
|
echo "# pkgconfig" >> "$QTCONFIG.tmp"
|
|
echo "PKG_CONFIG_SYSROOT_DIR = $PKG_CONFIG_SYSROOT_DIR" >> "$QTCONFIG.tmp"
|
|
echo "PKG_CONFIG_LIBDIR = $PKG_CONFIG_LIBDIR" >> "$QTCONFIG.tmp"
|
|
echo >> "$QTCONFIG.tmp"
|
|
fi
|
|
|
|
if [ -n "$CFG_SYSROOT" ] && [ "$CFG_GCC_SYSROOT" = "yes" ]; then
|
|
echo "# sysroot" >>"$QTCONFIG.tmp"
|
|
echo "!host_build {" >>"$QTCONFIG.tmp"
|
|
echo " QMAKE_CFLAGS += --sysroot=\$\$[QT_SYSROOT]" >>"$QTCONFIG.tmp"
|
|
echo " QMAKE_CXXFLAGS += --sysroot=\$\$[QT_SYSROOT]" >>"$QTCONFIG.tmp"
|
|
echo " QMAKE_LFLAGS += --sysroot=\$\$[QT_SYSROOT]" >>"$QTCONFIG.tmp"
|
|
echo "}" >> "$QTCONFIG.tmp"
|
|
echo >> "$QTCONFIG.tmp"
|
|
fi
|
|
if [ -n "$RPATH_FLAGS" ]; then
|
|
echo "QMAKE_RPATHDIR += $RPATH_FLAGS" >> "$QTCONFIG.tmp"
|
|
fi
|
|
if [ -n "$QT_GCC_MAJOR_VERSION" ]; then
|
|
echo "QT_GCC_MAJOR_VERSION = $QT_GCC_MAJOR_VERSION" >> "$QTCONFIG.tmp"
|
|
echo "QT_GCC_MINOR_VERSION = $QT_GCC_MINOR_VERSION" >> "$QTCONFIG.tmp"
|
|
echo "QT_GCC_PATCH_VERSION = $QT_GCC_PATCH_VERSION" >> "$QTCONFIG.tmp"
|
|
fi
|
|
if [ -n "$QT_ICC_MAJOR_VERSION" ]; then
|
|
echo "QT_ICC_MAJOR_VERSION = $QT_ICC_MAJOR_VERSION" >> "$QTCONFIG.tmp"
|
|
echo "QT_ICC_MINOR_VERSION = $QT_ICC_MINOR_VERSION" >> "$QTCONFIG.tmp"
|
|
echo "QT_ICC_PATCH_VERSION = $QT_ICC_PATCH_VERSION" >> "$QTCONFIG.tmp"
|
|
fi
|
|
if [ -n "$QT_CLANG_MAJOR_VERSION" ]; then
|
|
echo "QT_CLANG_MAJOR_VERSION = $QT_CLANG_MAJOR_VERSION" >> "$QTCONFIG.tmp"
|
|
echo "QT_CLANG_MINOR_VERSION = $QT_CLANG_MINOR_VERSION" >> "$QTCONFIG.tmp"
|
|
fi
|
|
if [ -n "$QT_APPLE_CLANG_MAJOR_VERSION" ]; then
|
|
echo "QT_APPLE_CLANG_MAJOR_VERSION = $QT_APPLE_CLANG_MAJOR_VERSION" >> "$QTCONFIG.tmp"
|
|
echo "QT_APPLE_CLANG_MINOR_VERSION = $QT_APPLE_CLANG_MINOR_VERSION" >> "$QTCONFIG.tmp"
|
|
fi
|
|
|
|
if [ -n "$QMAKE_INCDIR_OPENGL_ES2" ]; then
|
|
echo "#Qt opengl include path" >> "$QTCONFIG.tmp"
|
|
echo "QMAKE_INCDIR_OPENGL_ES2 = `shellArgumentListToQMakeList "$QMAKE_INCDIR_OPENGL_ES2"`" >> "$QTCONFIG.tmp"
|
|
fi
|
|
|
|
# replace qconfig.pri if it differs from the newly created temp file
|
|
if cmp -s "$QTCONFIG.tmp" "$QTCONFIG"; then
|
|
rm -f "$QTCONFIG.tmp"
|
|
else
|
|
mv -f "$QTCONFIG.tmp" "$QTCONFIG"
|
|
fi
|
|
|
|
#-------------------------------------------------------------------------------
|
|
# save configuration into qmodule.pri
|
|
#-------------------------------------------------------------------------------
|
|
QTMODULE="$outpath/mkspecs/qmodule.pri"
|
|
|
|
echo "CONFIG += $QMAKE_CONFIG" >> "$QTMODULE.tmp"
|
|
echo "QT_BUILD_PARTS += $CFG_BUILD_PARTS" >> "$QTMODULE.tmp"
|
|
if [ -n "$CFG_SKIP_MODULES" ]; then
|
|
echo "QT_SKIP_MODULES += $CFG_SKIP_MODULES" >> "$QTMODULE.tmp"
|
|
fi
|
|
DISABLED_FEATURES=
|
|
for cfg in $QCONFIG_FLAGS; do
|
|
ncfg=${cfg#QT_NO_}
|
|
if [ x$ncfg != x$cfg ]; then
|
|
DISABLED_FEATURES="$DISABLED_FEATURES $ncfg"
|
|
fi
|
|
done
|
|
if [ -n "$DISABLED_FEATURES" ]; then
|
|
echo "QT_NO_DEFINES = $DISABLED_FEATURES" >> "$QTMODULE.tmp"
|
|
fi
|
|
echo "QT_QCONFIG_PATH = ${CFG_QCONFIG_PATH#$relpath/src/corelib/global/}" >> "$QTMODULE.tmp"
|
|
|
|
cat >>"$QTMODULE.tmp" <<EOF
|
|
host_build {
|
|
QT_CPU_FEATURES.$CFG_HOST_ARCH = $CFG_HOST_CPUFEATURES
|
|
} else {
|
|
QT_CPU_FEATURES.$CFG_ARCH = $CFG_CPUFEATURES
|
|
}
|
|
EOF
|
|
echo "QT_COORD_TYPE = $CFG_QREAL" >> "$QTMODULE.tmp"
|
|
|
|
if [ -n "$QT_CFLAGS_PSQL" ]; then
|
|
echo "QT_CFLAGS_PSQL = $QT_CFLAGS_PSQL" >> "$QTMODULE.tmp"
|
|
fi
|
|
if [ -n "$QT_LFLAGS_PSQL" ]; then
|
|
echo "QT_LFLAGS_PSQL = $QT_LFLAGS_PSQL" >> "$QTMODULE.tmp"
|
|
fi
|
|
if [ -n "$QT_CFLAGS_MYSQL" ]; then
|
|
echo "QT_CFLAGS_MYSQL = $QT_CFLAGS_MYSQL" >> "$QTMODULE.tmp"
|
|
fi
|
|
if [ -n "$QT_LFLAGS_MYSQL" ]; then
|
|
echo "QT_LFLAGS_MYSQL = $QT_LFLAGS_MYSQL" >> "$QTMODULE.tmp"
|
|
fi
|
|
if [ -n "$QT_CFLAGS_SQLITE" ]; then
|
|
echo "QT_CFLAGS_SQLITE = $QT_CFLAGS_SQLITE" >> "$QTMODULE.tmp"
|
|
fi
|
|
if [ -n "$QT_LFLAGS_SQLITE" ]; then
|
|
echo "QT_LFLAGS_SQLITE = $QT_LFLAGS_SQLITE" >> "$QTMODULE.tmp"
|
|
fi
|
|
if [ -n "$QT_LFLAGS_ODBC" ]; then
|
|
echo "QT_LFLAGS_ODBC = $QT_LFLAGS_ODBC" >> "$QTMODULE.tmp"
|
|
fi
|
|
if [ -n "$QT_LFLAGS_TDS" ]; then
|
|
echo "QT_LFLAGS_TDS = $QT_LFLAGS_TDS" >> "$QTMODULE.tmp"
|
|
fi
|
|
|
|
if [ "$QT_EDITION" != "QT_EDITION_OPENSOURCE" ]; then
|
|
echo "DEFINES *= QT_EDITION=QT_EDITION_DESKTOP" >> "$QTMODULE.tmp"
|
|
fi
|
|
|
|
#dump in the OPENSSL_LIBS info
|
|
if [ '!' -z "$OPENSSL_LIBS" ]; then
|
|
echo "OPENSSL_LIBS = $OPENSSL_LIBS" >> "$QTMODULE.tmp"
|
|
elif [ "$CFG_OPENSSL" = "linked" ]; then
|
|
echo "OPENSSL_LIBS = -lssl -lcrypto" >> "$QTMODULE.tmp"
|
|
fi
|
|
|
|
# cmdline args
|
|
cat "$QMAKE_VARS_FILE" >> "$QTMODULE.tmp"
|
|
# QMAKE_VARS_FILE will be still needed for a status message.
|
|
|
|
# replace qmodule.pri if it differs from the newly created temp file
|
|
if cmp -s "$QTMODULE.tmp" "$QTMODULE"; then
|
|
rm -f "$QTMODULE.tmp"
|
|
else
|
|
mv -f "$QTMODULE.tmp" "$QTMODULE"
|
|
fi
|
|
|
|
#-------------------------------------------------------------------------------
|
|
# give feedback on configuration
|
|
#-------------------------------------------------------------------------------
|
|
exec 3>&1 1>$outpath/config.summary # redirect output temporarily to config.summary
|
|
|
|
report_support()
|
|
{
|
|
case "$#,$2" in
|
|
2,auto)
|
|
# 2 arguments and the result is "auto", so just say "yes"
|
|
# this is usually an error in the configure script, but oh well..
|
|
echo "$1 yes"
|
|
return
|
|
;;
|
|
[012],* | *,no*)
|
|
# 0, 1 or 2 arguments, or anything starting with "no"
|
|
# print just the first part of the argument (before the dash)
|
|
echo "$1 ${2%%-*}"
|
|
return
|
|
:;
|
|
esac
|
|
heading=$1
|
|
shift
|
|
|
|
value=$1
|
|
shift
|
|
|
|
while [ $# -gt 0 ]; do
|
|
if [ "$value" = "$1" ]; then
|
|
echo "$heading yes ($2)"
|
|
return
|
|
fi
|
|
shift
|
|
shift
|
|
done
|
|
echo "$heading $value"
|
|
}
|
|
|
|
report_support_plugin()
|
|
{
|
|
report_support "$1" "$2-$3" \
|
|
yes-qt "in $4, using bundled copy" \
|
|
yes-system "in $4, using system library" \
|
|
plugin-qt "plugin, using bundled copy" \
|
|
plugin-system "plugin, using system library"
|
|
}
|
|
|
|
echo
|
|
echo " Configure summary"
|
|
echo
|
|
if [ "$XPLATFORM" = "$PLATFORM" ]; then
|
|
# the missing space before $CFG_FEATURES is intentional
|
|
echo "Build type: $PLATFORM ($CFG_ARCH, CPU features:${CFG_CPUFEATURES- none detected})"
|
|
else
|
|
echo "Building on: $PLATFORM ($CFG_HOST_ARCH, CPU features:${CFG_HOST_CPUFEATURES- none detected})"
|
|
echo "Building for: $XPLATFORM ($CFG_ARCH, CPU features:${CFG_CPUFEATURES- none detected})"
|
|
fi
|
|
|
|
|
|
if [ -n "$PLATFORM_NOTES" ]; then
|
|
echo "Platform notes:"
|
|
echo "$PLATFORM_NOTES"
|
|
else
|
|
echo
|
|
fi
|
|
|
|
if [ "$OPT_VERBOSE" = "yes" ]; then
|
|
echo $ECHO_N "qmake vars .......... $ECHO_C"
|
|
cat "$QMAKE_VARS_FILE" | tr '\n' ' '
|
|
echo "qmake switches ......... $QMAKE_SWITCHES"
|
|
echo
|
|
fi
|
|
|
|
# Build configuration
|
|
echo "Build options:"
|
|
echo $ECHO_N " Configuration .......... $ECHO_C"
|
|
echo $QMAKE_CONFIG $QT_CONFIG | tr ' ' '\n' | sort | tr '\n' ' '
|
|
echo
|
|
echo " Build parts ............ $CFG_BUILD_PARTS"
|
|
release="release"
|
|
[ "$CFG_FORCEDEBUGINFO" = "yes" ] && release="release (with debug info)"
|
|
[ "$CFG_DEBUG" = "yes" ] && build_mode="debug" || build_mode=$release
|
|
if [ "$CFG_DEBUG_RELEASE" = "yes" ]; then
|
|
echo " Mode ................... debug and $release; default link: $build_mode"
|
|
else
|
|
echo " Mode ................... $build_mode"
|
|
fi
|
|
unset build_mode release
|
|
echo " Using C++11 ............ $CFG_CXX11"
|
|
echo " Using PCH .............. $CFG_PRECOMPILE"
|
|
echo " Target compiler supports:"
|
|
if [ "$CFG_ARCH" = "i386" -o "$CFG_ARCH" = "x86_64" ]; then
|
|
echo " SSE2/SSE3/SSSE3 ...... ${CFG_SSE2}/${CFG_SSE3}/${CFG_SSSE3}"
|
|
echo " SSE4.1/SSE4.2 ........ ${CFG_SSE4_1}/${CFG_SSE4_2}"
|
|
echo " AVX/AVX2 ............. ${CFG_AVX}/${CFG_AVX2}"
|
|
elif [ "$CFG_ARCH" = "arm" ]; then
|
|
echo " iWMMXt/Neon .......... ${CFG_IWMMXT}/${CFG_NEON}"
|
|
elif [ "$CFG_ARCH" = "mips" ]; then
|
|
echo " DSP/DSPr2 ............ ${CFG_MIPS_DSP}/${CFG_MIPS_DSPR2}"
|
|
fi
|
|
|
|
# Qt modules
|
|
echo
|
|
echo "Qt modules and options:"
|
|
report_support " Qt D-Bus ..............." "$CFG_DBUS" yes "loading dbus-1 at runtime" linked "linked to dbus-1"
|
|
report_support " Qt Concurrent .........." "$CFG_CONCURRENT"
|
|
report_support " Qt GUI ................." "$CFG_GUI"
|
|
report_support " Qt Widgets ............." "$CFG_WIDGETS"
|
|
report_support " JavaScriptCore JIT ....." "$CFG_JAVASCRIPTCORE_JIT" auto "To be decided by JavaScriptCore"
|
|
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 " FontConfig ............." "$CFG_FONTCONFIG"
|
|
report_support " FreeType ..............." "$CFG_FREETYPE"
|
|
[ "$CFG_HARFBUZZ" != "no" ] && \
|
|
report_support " HarfBuzz ..............." "$CFG_HARFBUZZ"
|
|
report_support " Iconv .................." "$CFG_ICONV"
|
|
report_support " ICU ...................." "$CFG_ICU"
|
|
report_support " Image formats:"
|
|
report_support_plugin " GIF .................." "$CFG_GIF" qt QtGui
|
|
report_support_plugin " JPEG ................." "$CFG_JPEG" "$CFG_LIBJPEG" QtGui
|
|
report_support_plugin " PNG .................." "$CFG_PNG" "$CFG_LIBPNG" QtGui
|
|
report_support " Glib ..................." "$CFG_GLIB"
|
|
report_support " GTK theme .............." "$CFG_QGTKSTYLE"
|
|
report_support " Large File ............." "$CFG_LARGEFILE"
|
|
report_support " Networking:"
|
|
[ "$XPLATFORM_MAC" = "yes" ] && \
|
|
report_support " CoreWlan ............." "$CFG_COREWLAN"
|
|
report_support " getaddrinfo .........." "$CFG_GETADDRINFO"
|
|
report_support " getifaddrs ..........." "$CFG_GETIFADDRS"
|
|
report_support " IPv6 ifname .........." "$CFG_IPV6IFNAME"
|
|
report_support " OpenSSL .............." "$CFG_OPENSSL" yes "loading libraries at run-time" linked "linked to the libraries"
|
|
report_support " NIS ...................." "$CFG_NIS"
|
|
report_support " OpenGL ................." "$CFG_OPENGL" yes "Desktop OpenGL" es2 "OpenGL ES 2.x"
|
|
report_support " OpenVG ................." "$CFG_OPENVG-$CFG_OPENVG_SHIVA" yes-yes "ShivaVG" yes-no "native"
|
|
report_support " PCRE ..................." "$CFG_PCRE" yes "system library" qt "bundled copy"
|
|
if [ -n "$PKG_CONFIG" ]; then
|
|
report_support " pkg-config ............. yes"
|
|
else
|
|
report_support " pkg-config ............. no"
|
|
fi
|
|
report_support " PulseAudio ............." "$CFG_PULSEAUDIO"
|
|
report_support " EGL ...................." "$CFG_EGL"
|
|
report_support " GLX ...................." "$CFG_GLX"
|
|
report_support " QPA backends:"
|
|
report_support " DirectFB ............." "$CFG_DIRECTFB"
|
|
report_support " EGLFS ................" "$CFG_EGLFS"
|
|
report_support " KMS .................." "$CFG_KMS"
|
|
report_support " LinuxFB .............." "$CFG_LINUXFB"
|
|
report_support " XCB .................." "$CFG_XCB" system "system library" qt "bundled copy"
|
|
if [ "$CFG_XCB" != "no" ]; then
|
|
report_support " MIT-SHM ............" "$CFG_MITSHM"
|
|
report_support " Xcb-Xlib ..........." "$CFG_XCB_XLIB"
|
|
report_support " Xcursor ............" "$CFG_XCURSOR" runtime "loaded at runtime"
|
|
report_support " Xfixes ............." "$CFG_XFIXES" runtime "loaded at runtime"
|
|
report_support " Xi ................." "$CFG_XINPUT" runtime "loaded at runtime"
|
|
report_support " Xi2 ................" "$CFG_XINPUT2" runtime "loaded at runtime"
|
|
report_support " Xinerama ..........." "$CFG_XINERAMA" runtime "loaded at runtime"
|
|
report_support " Xrandr ............." "$CFG_XRANDR" runtime "loaded at runtime"
|
|
report_support " Xrender ............" "$CFG_XRENDER"
|
|
report_support " XKB ................" "$CFG_XKB"
|
|
report_support " XShape ............." "$CFG_XSHAPE"
|
|
report_support " XSync .............." "$CFG_XSYNC"
|
|
report_support " XVideo ............." "$CFG_XVIDEO"
|
|
fi
|
|
report_support " Session management ....." "$CFG_SM"
|
|
if [ "$XPLATFORM_QNX" = "yes" ]; then
|
|
report_support " SLOG2 .................." "$CFG_SLOG2"
|
|
report_support " PPS ...................." "$CFG_PPS"
|
|
fi
|
|
report_support " SQL drivers:"
|
|
report_support " DB2 .................." "$CFG_SQL_db2" plugin "plugin" yes "built into QtSql"
|
|
report_support " InterBase ............" "$CFG_SQL_ibase" plugin "plugin" yes "built into QtSql"
|
|
report_support " MySQL ................" "$CFG_SQL_mysql" plugin "plugin" yes "built into QtSql"
|
|
report_support " OCI .................." "$CFG_SQL_oci" plugin "plugin" yes "built into QtSql"
|
|
report_support " ODBC ................." "$CFG_SQL_odbc" plugin "plugin" yes "built into QtSql"
|
|
report_support " PostgreSQL ..........." "$CFG_SQL_psql" plugin "plugin" yes "built into QtSql"
|
|
report_support " SQLite 2 ............." "$CFG_SQL_sqlite2" plugin "plugin" yes "built into QtSql"
|
|
report_support_plugin " SQLite ..............." "$CFG_SQL_sqlite" "$CFG_SQLITE" QtSql
|
|
report_support " TDS .................." "$CFG_SQL_tds" plugin "plugin" yes "built into QtSql"
|
|
report_support " udev ..................." "$CFG_LIBUDEV"
|
|
report_support " xkbcommon .............." "$CFG_XKBCOMMON" system "system library" qt "bundled copy"
|
|
report_support " zlib ..................." "$CFG_ZLIB" system "system library" yes "bundled copy"
|
|
|
|
echo
|
|
|
|
# complain about not being able to use dynamic plugins if we are using a static build
|
|
if [ "$CFG_SHARED" = "no" ]; then
|
|
echo
|
|
echo "WARNING: Using static linking will disable the use of dynamically"
|
|
echo "loaded plugins. Make sure to import all needed static plugins,"
|
|
echo "or compile needed modules into the library."
|
|
echo
|
|
fi
|
|
if [ "$CFG_OPENSSL" = "linked" ] && [ "$OPENSSL_LIBS" = "" ]; then
|
|
echo
|
|
echo "NOTE: When linking against OpenSSL, you can override the default"
|
|
echo "library names through OPENSSL_LIBS."
|
|
echo "For example:"
|
|
echo " OPENSSL_LIBS='-L/opt/ssl/lib -lssl -lcrypto' ./configure -openssl-linked"
|
|
echo
|
|
fi
|
|
if [ "$ORIG_CFG_XKBCOMMON" != qt ] && [ "$CFG_XKBCOMMON" = qt ]; then
|
|
echo "NOTE: libxkbcommon 0.2.0 (or higher) not found on the system, will use "
|
|
echo "the bundled version from 3rd party directory."
|
|
fi
|
|
if [ "$CFG_QREAL" = double ] && [ "$CFG_ARCH" = arm ]; then
|
|
echo "NOTE: Qt is using double for qreal on this system. This is binary incompatible against Qt 5.1."
|
|
echo "Configure with '-qreal float' to create a build that is binary compatible with 5.1."
|
|
fi
|
|
|
|
exec 1>&3 3>&- # restore stdout
|
|
cat $outpath/config.summary # display config feedback to user
|
|
|
|
if [ "$XPLATFORM_MAC" = "yes" ] && [ "$CFG_FRAMEWORK" = "yes" ] && [ "$CFG_DEBUG" = "yes" ] && [ "$CFG_DEBUG_RELEASE" = "no" ]; then
|
|
echo
|
|
echo "Error: debug-only framework builds are not supported. Configure with -no-framework"
|
|
echo "if you want a pure debug build."
|
|
echo
|
|
exit 1
|
|
fi
|
|
|
|
sepath=`echo "$relpath" | sed -e 's/\\./\\\\./g'`
|
|
PROCS=1
|
|
EXEC=""
|
|
|
|
rm -f "$QMAKE_VARS_FILE" 2>/dev/null
|
|
|
|
#-------------------------------------------------------------------------------
|
|
# build makefiles based on the configuration
|
|
#-------------------------------------------------------------------------------
|
|
|
|
if [ "$CFG_PROCESS" != "no" ]; then
|
|
( # fork to make the cd stay local
|
|
|
|
relpathMangled=$relpath
|
|
if [ -n "$CFG_TOPLEVEL" ]; then
|
|
relpathMangled=`dirname "$relpath"`
|
|
cd ..
|
|
fi
|
|
|
|
if [ "$CFG_PROCESS" = "full" ]; then
|
|
echo "Creating makefiles. Please wait..."
|
|
"$outpath/bin/qmake" -r "$relpathMangled"
|
|
echo "Done"
|
|
else
|
|
"$outpath/bin/qmake" "$relpathMangled"
|
|
fi
|
|
|
|
)
|
|
fi
|
|
|
|
#-------------------------------------------------------------------------------
|
|
# check for platforms that we don't yet know about
|
|
#-------------------------------------------------------------------------------
|
|
if [ "$CFG_ARCH" = "unknown" ]; then
|
|
cat <<EOF
|
|
|
|
NOTICE: configure was unable to determine the architecture
|
|
for the $XQMAKESPEC target.
|
|
|
|
Qt will not use a specialized implementation for any atomic
|
|
operations. Instead a generic implemention based on either GCC
|
|
intrinsics or C++11 std::atomic<T> will be used (when
|
|
available). The generic implementations are generally as fast
|
|
as and always as safe as a specialized implementation.
|
|
|
|
If no generic implementation is available, Qt will use a
|
|
fallback UNIX implementation which uses a single
|
|
pthread_mutex_t to protect all atomic operations. This
|
|
implementation is the slow (but safe) fallback implementation
|
|
for architectures Qt does not yet support.
|
|
EOF
|
|
fi
|
|
|
|
#-------------------------------------------------------------------------------
|
|
# check if the user passed the -no-zlib option, which is no longer supported
|
|
#-------------------------------------------------------------------------------
|
|
if [ -n "$ZLIB_FORCED" ]; then
|
|
which_zlib="supplied"
|
|
if [ "$CFG_ZLIB" = "system" ]; then
|
|
which_zlib="system"
|
|
fi
|
|
|
|
cat <<EOF
|
|
|
|
NOTICE: The -no-zlib option was supplied but is no longer
|
|
supported.
|
|
|
|
Qt now requires zlib support in all builds, so the -no-zlib
|
|
option was ignored. Qt will be built using the $which_zlib
|
|
zlib.
|
|
EOF
|
|
fi
|
|
|
|
#-------------------------------------------------------------------------------
|
|
# check if the user passed the obsoleted -wayland or -no-wayland flag
|
|
#-------------------------------------------------------------------------------
|
|
if [ "$CFG_OBSOLETE_WAYLAND" = "yes" ]; then
|
|
cat <<EOF
|
|
|
|
NOTICE: The -wayland and -no-wayland flags are now obsolete
|
|
|
|
All configuring of QtWayland plugin and QtCompositor happens in the module
|
|
EOF
|
|
fi
|
|
|
|
#-------------------------------------------------------------------------------
|
|
# check if the user passed the obsoleted -arch or -host-arch options
|
|
#-------------------------------------------------------------------------------
|
|
if [ "$OPT_OBSOLETE_HOST_ARG" = "yes" ]; then
|
|
cat <<EOF
|
|
|
|
NOTICE: The -arch and -host-arch options are obsolete.
|
|
|
|
Qt now detects the target and host architectures based on compiler
|
|
output. Qt will be built using $CFG_ARCH for the target architecture
|
|
and $CFG_HOST_ARCH for the host architecture (note that these two
|
|
will be the same unless you are cross-compiling).
|
|
EOF
|
|
fi
|
|
|
|
#-------------------------------------------------------------------------------
|
|
# finally save the executed command to another script
|
|
#-------------------------------------------------------------------------------
|
|
if [ `basename $0` != "config.status" ]; then
|
|
CONFIG_STATUS="$relpath/$relconf $OPT_CMDLINE"
|
|
|
|
# add the system variables
|
|
for varname in $SYSTEM_VARIABLES; do
|
|
cmd=`echo \
|
|
'if [ -n "\$'${varname}'" ]; then
|
|
CONFIG_STATUS="'${varname}'='"'\\\$${varname}'"' \$CONFIG_STATUS"
|
|
fi'`
|
|
eval "$cmd"
|
|
done
|
|
|
|
echo "$CONFIG_STATUS" | grep '\-confirm\-license' >/dev/null 2>&1 || CONFIG_STATUS="$CONFIG_STATUS -confirm-license"
|
|
|
|
[ -f "$outpath/config.status" ] && rm -f "$outpath/config.status"
|
|
echo "#!/bin/sh" > "$outpath/config.status"
|
|
[ -n "$PKG_CONFIG_SYSROOT_DIR" ] && \
|
|
echo "export PKG_CONFIG_SYSROOT_DIR=$PKG_CONFIG_SYSROOT_DIR" >> "$outpath/config.status"
|
|
[ -n "$PKG_CONFIG_LIBDIR" ] && \
|
|
echo "export PKG_CONFIG_LIBDIR=$PKG_CONFIG_LIBDIR" >> "$outpath/config.status"
|
|
echo "if [ \"\$#\" -gt 0 ]; then" >> "$outpath/config.status"
|
|
echo " $CONFIG_STATUS \"\$@\"" >> "$outpath/config.status"
|
|
echo "else" >> "$outpath/config.status"
|
|
echo " $CONFIG_STATUS" >> "$outpath/config.status"
|
|
echo "fi" >> "$outpath/config.status"
|
|
chmod +x "$outpath/config.status"
|
|
fi
|
|
|
|
if [ -n "$RPATH_MESSAGE" ]; then
|
|
echo
|
|
echo "$RPATH_MESSAGE"
|
|
fi
|
|
|
|
MAKE=`basename "$MAKE"`
|
|
echo
|
|
echo Qt is now configured for building. Just run \'$MAKE\'.
|
|
if [ "$outpath" = "$QT_INSTALL_PREFIX" ]; then
|
|
echo Once everything is built, Qt is installed.
|
|
echo You should not run \'$MAKE install\'.
|
|
else
|
|
echo Once everything is built, you must run \'$MAKE install\'.
|
|
echo Qt will be installed into $QT_INSTALL_PREFIX
|
|
fi
|
|
echo
|
|
echo Prior to reconfiguration, make sure you remove any leftovers from
|
|
echo the previous build.
|
|
echo
|