AuroraMiddleware/qt5base-lts
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
ce942a2265
qt5base-lts/configure
Oswald Buddenhagen d90db0f136 rewrite makespec verification with qmake based system 
cleaner, and covers windows as well.

Change-Id: I0e884909a3f49610fab750ba1ef6112f43e5d5d1
Reviewed-by: Lars Knoll <lars.knoll@qt.io>
Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io>
2016-08-18 17:10:52 +00:00

1976 lines
60 KiB
Bash
Executable File
Raw Blame History

#!/bin/sh
#############################################################################
##
## Copyright (C) 2016 The Qt Company Ltd.
## Copyright (C) 2016 Intel Corporation.
## Contact: https://www.qt.io/licensing/
##
## This file is the build configuration utility of the Qt Toolkit.
##
## $QT_BEGIN_LICENSE:GPL-EXCEPT$
## Commercial License Usage
## Licensees holding valid commercial Qt licenses may use this file in
## accordance with the commercial license agreement provided with the
## Software or, alternatively, in accordance with the terms contained in
## a written agreement between you and The Qt Company. For licensing terms
## and conditions see https://www.qt.io/terms-conditions. For further
## information use the contact form at https://www.qt.io/contact-us.
##
## GNU General Public License Usage
## Alternatively, this file may be used under the terms of the GNU
## General Public License version 3 as published by the Free Software
## Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
## included in the packaging of this file. Please review the following
## information to ensure the GNU General Public License requirements will
## be met: https://www.gnu.org/licenses/gpl-3.0.html.
##
## $QT_END_LICENSE$
##
#############################################################################
#-------------------------------------------------------------------------------
# script initialization
#-------------------------------------------------------------------------------
# the name of this script
relconf=`basename $0`
# the directory of this script is the "source tree"
relpath=`dirname $0`
relpath=`(cd "$relpath"; /bin/pwd)`
# the current directory is the "build tree" or "object tree"
outpath=`/bin/pwd`
# where to find which..
unixtests="$relpath/config.tests/unix"
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
CFG_REDO=no
OPT_CMDLINE= # excluding -verbose (for config.opt)
QMAKE_CMDLINE= # including -verbose (for actual parsing)
set -f # suppress globbing in for loop
SAVED_IFS=$IFS
IFS='
'
for i in "$@"; do
case $i in
-redo|--redo)
if ! test -f config.opt; then
echo >&2 "No config.opt present - cannot redo configuration."
exit 1
fi
for a in `cat config.opt`; do
OPT_CMDLINE="$OPT_CMDLINE
$a"
QMAKE_CMDLINE="$QMAKE_CMDLINE
$a"
done
CFG_REDO=yes # suppress repeated config.opt writeout
continue
;;
-v|-verbose|--verbose|-no-v|-no-verbose|--no-verbose)
;;
*)
OPT_CMDLINE="$OPT_CMDLINE
$i"
;;
esac
QMAKE_CMDLINE="$QMAKE_CMDLINE
$i"
done
set --
for i in $QMAKE_CMDLINE; do
set -- "$@" "$i"
done
set +f
IFS=$SAVED_IFS
# initialize global variables
DEVICE_VARS_FILE=.device.vars
HOST_VARS_FILE=.host.vars
:> "$DEVICE_VARS_FILE"
:> "$HOST_VARS_FILE"
#-------------------------------------------------------------------------------
# utility functions
#-------------------------------------------------------------------------------
makeabs()
{
local FILE="$1"
local RES="$FILE"
if [ -z "${FILE##/*}" ]; then
true
elif [ "$OSTYPE" = "msys" -a -z "${FILE##[a-zA-Z]:[/\\]*}" ]; then
true
else
RES=$PWD/$FILE
fi
RES=$RES/
while true; do
nres=`echo "$RES" | sed 's,/[^/][^/]*/\.\./,/,g; s,/\./,/,g'`
test x"$nres" = x"$RES" && break
RES=$nres
done
echo "$RES" | sed 's,//,/,g; s,/$,,'
}
# Helper function for getQMakeConf. It parses include statements in
# qmake.conf and prints out the expanded file
expandQMakeConf()
{
while read line; do case "$line" in
include*)
inc_file=`echo "$line" | sed -n -e '/^include.*(.*)/s/include.*(\(.*\)).*$/\1/p'`
current_dir=`dirname "$1"`
conf_file="$current_dir/$inc_file"
if [ ! -f "$conf_file" ]; then
echo "WARNING: Unable to find file $conf_file" >&2
continue
fi
expandQMakeConf "$conf_file" "$2"
;;
*load\(device_config\)*)
conf_file="$2"
if [ ! -f "$conf_file" ]; then
echo "WARNING: Unable to find file $conf_file" >&2
continue
fi
expandQMakeConf "$conf_file" "$2"
;;
*)
echo "$line"
;;
esac; done < "$1"
}
extractQMakeVariables()
{
LC_ALL=C $AWK '
BEGIN {
values["LITERAL_WHITESPACE"] = " "
values["LITERAL_DOLLAR"] = "$"
}
/^!?host_build:/ {
scopeStart = index($0, ":") + 1
condition = substr($0, 0, scopeStart - 2)
if (condition != "'"$1"'") { next }
$0 = substr($0, scopeStart)
}
/^[_A-Z0-9.]+[ \t]*\+?=/ {
valStart = index($0, "=") + 1
append = 0
if (substr($0, valStart - 2, 1) == "+") {
append = 1
}
variable = substr($0, 0, valStart - 2 - append)
value = substr($0, valStart)
gsub("[ \t]+", "", variable)
gsub("^[ \t]+", "", value)
gsub("[ \t]+$", "", value)
ovalue = ""
while (match(value, /\$\$(\{[_A-Z0-9.]+\}|[_A-Z0-9.]+)/)) {
ovalue = ovalue substr(value, 1, RSTART - 1)
var = substr(value, RSTART + 2, RLENGTH - 2)
value = substr(value, RSTART + RLENGTH)
if (var ~ /^\{/) {
var = substr(var, 2, length(var) - 2)
}
ovalue = ovalue values[var]
}
value = ovalue value
ovalue = ""
while (match(value, /\$\$system\(("[^"]*"|[^)]*)\)/)) {
ovalue = ovalue substr(value, 1, RSTART - 1)
cmd = substr(value, RSTART + 9, RLENGTH - 10)
gsub(/^"|"$/, "", cmd)
value = substr(value, RSTART + RLENGTH)
while ((cmd | getline line) > 0) {
ovalue = ovalue line
}
close(cmd)
}
value = ovalue value
combinedValue = values[variable]
if (append == 1 && length(combinedValue) > 0) {
combinedValue = combinedValue " " value
} else {
combinedValue = value
}
values[variable] = combinedValue
}
END {
for (var in values) {
print var "=" values[var]
}
}
'
}
getSingleQMakeVariable()
{
echo "$2" | $AWK "/^($1)=/ { print substr(\$0, index(\$0, \"=\") + 1) }"
}
macSDKify()
{
# Normally we take care of sysrootifying in sdk.prf, but configure extracts some
# values before qmake is even built, so we have to duplicate the logic here.
sdk=$(getSingleQMakeVariable "QMAKE_MAC_SDK" "$1")
if [ -z "$sdk" ]; then echo "QMAKE_MAC_SDK must be set when building on Mac" >&2; exit 1; fi
sysroot=$(/usr/bin/xcodebuild -sdk $sdk -version Path 2>/dev/null)
if [ -z "$sysroot" ]; then echo "Failed to resolve SDK path for '$sdk'" >&2; exit 1; fi
case "$sdk" in
macosx*)
version_min_flag="-mmacosx-version-min=$(getSingleQMakeVariable QMAKE_MACOSX_DEPLOYMENT_TARGET "$1")"
;;
iphoneos*)
version_min_flag="-miphoneos-version-min=$(getSingleQMakeVariable QMAKE_IOS_DEPLOYMENT_TARGET "$1")"
;;
iphonesimulator*)
version_min_flag="-mios-simulator-version-min=$(getSingleQMakeVariable QMAKE_IOS_DEPLOYMENT_TARGET "$1")"
;;
appletvos*)
version_min_flag="-mappletvos-version-min=$(getSingleQMakeVariable QMAKE_TVOS_DEPLOYMENT_TARGET "$1")"
;;
appletvsimulator*)
version_min_flag="-mtvos-simulator-version-min=$(getSingleQMakeVariable QMAKE_TVOS_DEPLOYMENT_TARGET "$1")"
;;
*)
;;
esac
echo "$1" | while read line; do
case "$line" in
QMAKE_CC=*|QMAKE_CXX=*|QMAKE_FIX_RPATH=*|QMAKE_AR=*|QMAKE_RANLIB=*|QMAKE_LINK=*|QMAKE_LINK_SHLIB=*)
# Prefix tool with toolchain path
var=$(echo "$line" | cut -d '=' -f 1)
val=$(echo "$line" | cut -d '=' -f 2-)
sdk_val=$(/usr/bin/xcrun -sdk $sdk -find $(echo $val | cut -d ' ' -f 1))
val=$(echo $sdk_val $(echo $val | cut -s -d ' ' -f 2-))
echo "$var=$val"
;;
QMAKE_CFLAGS=*|QMAKE_CXXFLAGS=*)
echo "$line -isysroot $sysroot $version_min_flag"
;;
QMAKE_LFLAGS=*)
echo "$line -Wl,-syslibroot,$sysroot $version_min_flag"
;;
*)
echo "$line"
;;
esac
done
}
# relies on $QMAKESPEC being set correctly. parses include statements in
# qmake.conf and prints out the expanded file
getQMakeConf()
{
if [ -z "$specvals" ]; then
specvals=`expandQMakeConf "$QMAKESPEC/qmake.conf" "$HOST_VARS_FILE" | extractQMakeVariables "host_build"`
if [ "$BUILD_ON_MAC" = "yes" ]; then specvals=$(macSDKify "$specvals"); fi
fi
getSingleQMakeVariable "$1" "$specvals"
}
getXQMakeConf()
{
if [ -z "$xspecvals" ]; then
xspecvals=`expandQMakeConf "$XQMAKESPEC/qmake.conf" "$DEVICE_VARS_FILE" | extractQMakeVariables "!host_build"`
if [ "$XPLATFORM_MAC" = "yes" ]; then xspecvals=$(macSDKify "$xspecvals"); fi
fi
getSingleQMakeVariable "$1" "$xspecvals"
}
#-------------------------------------------------------------------------------
# device options
#-------------------------------------------------------------------------------
DeviceVar()
{
case "$1" in
set)
eq="="
;;
*)
echo >&2 "BUG: wrong command to DeviceVar: $1"
;;
esac
echo "$2" "$eq" "$3" >> "$DEVICE_VARS_FILE"
}
resolveDeviceMkspec()
{
result=$(find "$relpath/mkspecs/devices/" -type d -name "*$1*" | sed "s,^$relpath/mkspecs/,,")
match_count=$(echo "$result" | wc -w)
if [ "$match_count" -gt 1 ]; then
echo >&2 "Error: Multiple matches for device '$1'. Candidates are:"
tabbed_result=$(echo "$result" | sed 's,^, ,')
echo >&2 "$tabbed_result"
echo "undefined"
elif [ "$match_count" -eq 0 ]; then
echo >&2 "Error: No device matching '$1'"
echo "undefined"
else
echo "$result"
fi
}
#-------------------------------------------------------------------------------
# Host options
#-------------------------------------------------------------------------------
HostVar()
{
case "$1" in
set)
eq="="
;;
*)
echo >&2 "BUG: wrong command to HostVar: $1"
;;
esac
echo "$2" "$eq" "$3" >> "$HOST_VARS_FILE"
}
#-------------------------------------------------------------------------------
# operating system detection
#-------------------------------------------------------------------------------
# need that throughout the script
UNAME_MACHINE=`(uname -m) 2>/dev/null` || UNAME_MACHINE=unknown
UNAME_RELEASE=`(uname -r) 2>/dev/null` || UNAME_RELEASE=unknown
UNAME_SYSTEM=`(uname -s) 2>/dev/null` || UNAME_SYSTEM=unknown
UNAME_VERSION=`(uname -v) 2>/dev/null` || UNAME_VERSION=unknown
# detect the "echo without newline" style. usage: echo $ECHO_N "<string>$ECHO_C"
if echo '\c' | grep '\c' >/dev/null; then
ECHO_N=-n
else
ECHO_C='\c'
fi
BUILD_ON_MAC=no
if [ -d /System/Library/Frameworks/Carbon.framework ]; then
BUILD_ON_MAC=yes
fi
if [ "$OSTYPE" = "msys" ]; then
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 xcodebuild >/dev/null 2>&1; then
echo >&2
echo " Xcode not set up properly. You may need to confirm the license" >&2
echo " agreement by running /usr/bin/xcodebuild without arguments." >&2
echo >&2
exit 2
fi
fi
#-----------------------------------------------------------------------------
# Qt version detection
#-----------------------------------------------------------------------------
QT_VERSION=
QT_MAJOR_VERSION=
QT_MINOR_VERSION=0
QT_PATCH_VERSION=0
eval `sed -n -e 's/^MODULE_VERSION = \(\([0-9]*\)\.\([0-9]*\)\.\([0-9]*\).*\)$/QT_VERSION=\1\
QT_MAJOR_VERSION=\2\
QT_MINOR_VERSION=\3\
QT_PATCH_VERSION=\4/p' < "$relpath"/.qmake.conf`
if [ -z "$QT_MAJOR_VERSION" ]; then
echo "Cannot process version from .qmake.conf"
echo "Cannot proceed."
exit 1
fi
#-------------------------------------------------------------------------------
# initalize variables
#-------------------------------------------------------------------------------
# Use CC/CXX to run config.tests
mkdir -p "$outpath/config.tests"
rm -f "$outpath/config.tests/.qmake.cache"
: > "$outpath/config.tests/.qmake.cache"
# QTDIR may be set and point to an old or system-wide Qt installation
unset QTDIR
# initalize internal variables
CFG_RELEASE_TOOLS=no
CFG_ANDROID_STYLE_ASSETS=yes
XPLATFORM= # This seems to be the QMAKESPEC, like "linux-g++"
XPLATFORM_MAC=no # Whether target platform is OS X, iOS or tvOS
XPLATFORM_IOS=no # Whether target platform is iOS
XPLATFORM_TVOS=no # Whether target platform is tvOS
XPLATFORM_ANDROID=no
XPLATFORM_MINGW=no # Whether target platform is MinGW (win32-g++*)
PLATFORM=$QMAKESPEC
OPT_CONFIRM_LICENSE=no
OPT_SHADOW=maybe
OPT_VERBOSE=no
OPT_HELP=
CFG_SILENT=no
OPT_MAC_SDK=
COMMERCIAL_USER=ask
CFG_DEV=no
# initalize variables used for installation
QT_INSTALL_PREFIX=
QT_INSTALL_DOCS=
QT_INSTALL_HEADERS=
QT_INSTALL_LIBS=
QT_INSTALL_BINS=
QT_INSTALL_LIBEXECS=
QT_INSTALL_PLUGINS=
QT_INSTALL_IMPORTS=
QT_INSTALL_QML=
QT_INSTALL_ARCHDATA=
QT_INSTALL_DATA=
QT_INSTALL_TRANSLATIONS=
QT_INSTALL_SETTINGS=
QT_INSTALL_EXAMPLES=
QT_INSTALL_TESTS=
CFG_SYSROOT=
QT_HOST_PREFIX=
QT_HOST_BINS=
QT_HOST_LIBS=
QT_HOST_DATA=
QT_EXT_PREFIX=
# default qpa platform
# Android vars
CFG_DEFAULT_ANDROID_NDK_ROOT=$ANDROID_NDK_ROOT
CFG_DEFAULT_ANDROID_SDK_ROOT=$ANDROID_SDK_ROOT
CFG_DEFAULT_ANDROID_PLATFORM=android-16
CFG_DEFAULT_ANDROID_TARGET_ARCH=armeabi-v7a
CFG_DEFAULT_ANDROID_NDK_TOOLCHAIN_VERSION=4.9
CFG_DEFAULT_ANDROID_NDK_HOST=$ANDROID_NDK_HOST
#-------------------------------------------------------------------------------
# parse command line arguments
#-------------------------------------------------------------------------------
# parse the arguments, setting things to "yes" or "no"
while [ "$#" -gt 0 ]; do
CURRENT_OPT="$1"
UNKNOWN_ARG=no
case "$1" in
#Autoconf style options
--enable-*)
VAR=`echo $1 | sed 's,^--enable-\(.*\),\1,'`
VAL=yes
;;
--disable-*)
VAR=`echo $1 | sed 's,^--disable-\(.*\),\1,'`
VAL=no
;;
--*=*)
VAR=`echo $1 | sed 's,^--\(.*\)=.*,\1,'`
VAL=`echo $1 | sed 's,^--.*=\(.*\),\1,'`
;;
--no-*)
VAR=`echo $1 | sed 's,^--no-\(.*\),\1,'`
VAL=no
;;
--*)
VAR=`echo $1 | sed 's,^--\(.*\),\1,'`
VAL=yes
;;
#Qt plugin options
-no-*-*|-plugin-*-*|-qt-*-*)
VAR=`echo $1 | sed 's,^-[^-]*-\(.*\),\1,'`
VAL=`echo $1 | sed 's,^-\([^-]*\).*,\1,'`
;;
#Qt style no options
-no-*)
VAR=`echo $1 | sed 's,^-no-\(.*\),\1,'`
VAL=no
;;
#Qt style options that pass an argument
-prefix| \
-docdir| \
-headerdir| \
-plugindir| \
-importdir| \
-qmldir| \
-archdatadir| \
-datadir| \
-libdir| \
-bindir| \
-libexecdir| \
-translationdir| \
-sysconfdir| \
-examplesdir| \
-testsdir| \
-hostdatadir| \
-hostbindir| \
-hostlibdir| \
-extprefix| \
-sysroot| \
-external-hostbindir| \
-make| \
-nomake| \
-skip| \
-platform| \
-xplatform| \
-device| \
-device-option| \
-host-option| \
-sdk| \
-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,'`
;;
#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
-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
;;
#General options, including Qt style yes options
-*)
VAR=`echo $1 | sed 's,^-\(.*\),\1,'`
VAL="yes"
;;
# most options don't need processing in the configure script, skip them. qmake will do the real validation
*)
shift
continue
;;
esac
shift
UNKNOWN_OPT=no
case "$VAR" in
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)
;;
force-pkg-config)
;;
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"
;;
translationdir)
QT_INSTALL_TRANSLATIONS="$VAL"
;;
sysconfdir|settingsdir)
QT_INSTALL_SETTINGS="$VAL"
;;
examplesdir)
QT_INSTALL_EXAMPLES="$VAL"
;;
testsdir)
QT_INSTALL_TESTS="$VAL"
;;
sysroot)
CFG_SYSROOT="$VAL"
;;
external-hostbindir)
CFG_HOST_QT_TOOLS_PATH="$VAL"
HostVar set HOST_QT_TOOLS "$VAL"
;;
bindir)
QT_INSTALL_BINS="$VAL"
;;
libexecdir)
QT_INSTALL_LIBEXECS="$VAL"
;;
sdk)
if [ "$BUILD_ON_MAC" = "yes" ]; then
DeviceVar set !host_build:QMAKE_MAC_SDK "$VAL"
OPT_MAC_SDK="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
platform)
PLATFORM="$VAL"
;;
xplatform)
XPLATFORM="$VAL"
;;
device)
XPLATFORM=`resolveDeviceMkspec $VAL`
[ "$XPLATFORM" = "undefined" ] && exit 101
;;
device-option)
DEV_VAR=`echo $VAL | cut -d '=' -f 1`
DEV_VAL=`echo $VAL | cut -d '=' -f 2-`
DeviceVar set $DEV_VAR "$DEV_VAL"
;;
host-option)
HOST_VAR=`echo $VAL | cut -d '=' -f 1`
HOST_VAL=`echo $VAL | cut -d '=' -f 2-`
HostVar set $HOST_VAR "$HOST_VAL"
;;
optimized-qmake|optimized-tools)
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
CFG_RELEASE_TOOLS="$VAL"
fi
;;
developer-build)
CFG_DEV="yes"
;;
commercial)
COMMERCIAL_USER="yes"
;;
opensource)
COMMERCIAL_USER="no"
;;
feature-*)
FEATURE=`echo $VAR | sed 's,^[^-]*-\([^-]*\),\1,' | tr 'abcdefghijklmnopqrstuvwxyz-' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ_'`
if grep "^Feature: *${FEATURE} *\$" "$relpath"/src/corelib/global/qfeatures.txt >/dev/null 2>&1; then
F=`echo $VAR | sed 's,^[^-]*-\([^-]*\),\1,'`
if [ "$VAL" = "no" ]; then
F="no-$F"
elif [ "$VAL" != "yes" ] && [ "$VAL" != "unknown" ]; then
UNKNOWN_OPT=yes
fi
CFG_FEATURES="$CFG_FEATURES $F"
else
echo "ERROR: Unknown feature $FEATURE"
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
;;
v|verbose)
if [ "$VAL" = "yes" ]; then
OPT_VERBOSE=yes
elif [ "$VAL" = "no" ]; then
OPT_VERBOSE=no
else
UNKNOWN_OPT=yes
fi
;;
silent)
# need to keep this here, to ensure qmake is built silently
CFG_SILENT="$VAL"
;;
android-sdk)
CFG_DEFAULT_ANDROID_SDK_ROOT="$VAL"
;;
android-ndk)
CFG_DEFAULT_ANDROID_NDK_ROOT="$VAL"
;;
android-ndk-platform)
CFG_DEFAULT_ANDROID_PLATFORM="$VAL"
;;
android-ndk-host)
CFG_DEFAULT_ANDROID_NDK_HOST="$VAL"
;;
android-arch)
CFG_DEFAULT_ANDROID_TARGET_ARCH="$VAL"
;;
android-toolchain-version)
CFG_DEFAULT_ANDROID_NDK_TOOLCHAIN_VERSION="$VAL"
;;
android-style-assets)
# Required to be able to show the correct license text
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
CFG_ANDROID_STYLE_ASSETS="$VAL"
fi
;;
*)
;;
esac
if [ "$UNKNOWN_OPT" = "yes" ]; then
echo "${CURRENT_OPT}: invalid command-line switch"
ERROR=yes
fi
done
[ "x$ERROR" = "xyes" ] && exit 1
#-------------------------------------------------------------------------------
# help - interactive parts of the script _after_ this section please
#-------------------------------------------------------------------------------
if [ "$OPT_HELP" = "yes" ]; then
cat $relpath/config_help.txt
exit 0
fi
#-------------------------------------------------------------------------------
# platform detection
#-------------------------------------------------------------------------------
if [ -z "$PLATFORM" ]; then
PLATFORM_NOTES=
case "$UNAME_SYSTEM:$UNAME_RELEASE" in
Darwin:*)
PLATFORM=macx-clang
;;
AIX:*)
#PLATFORM=aix-g++
#PLATFORM=aix-g++-64
PLATFORM=aix-xlc
#PLATFORM=aix-xlc-64
PLATFORM_NOTES="
- Also available for AIX: aix-g++ aix-g++-64 aix-xlc-64
"
;;
GNU:*)
PLATFORM=hurd-g++
;;
dgux:*)
PLATFORM=dgux-g++
;;
# DYNIX/ptx:4*)
# PLATFORM=dynix-g++
# ;;
ULTRIX:*)
PLATFORM=ultrix-g++
;;
FreeBSD:*)
if [ "$(uname -r | cut -d. -f1)" -ge 10 ]; then
PLATFORM=freebsd-clang
PLATFORM_NOTES="
- Also available for FreeBSD: freebsd-g++
"
else
PLATFORM=freebsd-g++
PLATFORM_NOTES="
- Also available for FreeBSD: freebsd-clang
"
fi
;;
OpenBSD:*)
PLATFORM=openbsd-g++
;;
NetBSD:*)
PLATFORM=netbsd-g++
;;
BSD/OS:*|BSD/386:*)
PLATFORM=bsdi-g++
;;
IRIX*:*)
#PLATFORM=irix-g++
PLATFORM=irix-cc
#PLATFORM=irix-cc-64
PLATFORM_NOTES="
- Also available for IRIX: irix-g++ irix-cc-64
"
;;
HP-UX:*)
case "$UNAME_MACHINE" in
ia64)
#PLATFORM=hpuxi-acc-32
PLATFORM=hpuxi-acc-64
PLATFORM_NOTES="
- Also available for HP-UXi: hpuxi-acc-32
"
;;
*)
#PLATFORM=hpux-g++
PLATFORM=hpux-acc
#PLATFORM=hpux-acc-64
#PLATFORM=hpux-cc
#PLATFORM=hpux-acc-o64
PLATFORM_NOTES="
- Also available for HP-UX: hpux-g++ hpux-acc-64 hpux-acc-o64
"
;;
esac
;;
OSF1:*)
#PLATFORM=tru64-g++
PLATFORM=tru64-cxx
PLATFORM_NOTES="
- Also available for Tru64: tru64-g++
"
;;
Linux:*)
PLATFORM=linux-g++
PLATFORM_NOTES="
- Also available for Linux: linux-clang linux-kcc linux-icc linux-cxx
"
;;
SunOS:5*)
#PLATFORM=solaris-g++
PLATFORM=solaris-cc
#PLATFORM=solaris-cc64
PLATFORM_NOTES="
- Also available for Solaris: solaris-g++ solaris-cc-64
"
;;
ReliantUNIX-*:*|SINIX-*:*)
PLATFORM=reliant-cds
#PLATFORM=reliant-cds-64
PLATFORM_NOTES="
- Also available for Reliant UNIX: reliant-cds-64
"
;;
CYGWIN*:*)
PLATFORM=cygwin-g++
;;
LynxOS*:*)
PLATFORM=lynxos-g++
;;
OpenUNIX:*)
#PLATFORM=unixware-g++
PLATFORM=unixware-cc
PLATFORM_NOTES="
- Also available for OpenUNIX: unixware-g++
"
;;
UnixWare:*)
#PLATFORM=unixware-g++
PLATFORM=unixware-cc
PLATFORM_NOTES="
- Also available for UnixWare: unixware-g++
"
;;
SCO_SV:*)
#PLATFORM=sco-g++
PLATFORM=sco-cc
PLATFORM_NOTES="
- Also available for SCO OpenServer: sco-g++
"
;;
UNIX_SV:*)
PLATFORM=unixware-g++
;;
QNX:*)
PLATFORM=unsupported/qnx-g++
;;
*)
echo >&2
echo " The build script does not currently recognize all" >&2
echo " platforms supported by Qt." >&2
echo " Rerun this script with a -platform option listed to" >&2
echo " set the system/compiler combination you use." >&2
echo >&2
exit 2
esac
fi
[ -z "$XPLATFORM" ] && XPLATFORM="$PLATFORM"
case "$XPLATFORM" in
*win32-g++*)
XPLATFORM_MINGW=yes
;;
*qnx-*)
;;
*haiku-*)
;;
*ios*)
XPLATFORM_MAC=yes
XPLATFORM_IOS=yes
;;
*tvos*)
XPLATFORM_MAC=yes
XPLATFORM_TVOS=yes
;;
*macx*)
XPLATFORM_MAC=yes
;;
*integrity*)
;;
# XPLATFORM_ANDROID should not be set for unsupported/android-g++
*unsupported*)
;;
*android-g++*)
XPLATFORM_ANDROID=g++
;;
*android-clang*)
XPLATFORM_ANDROID=clang
;;
esac
#-------------------------------------------------------------------------------
# check the license
#-------------------------------------------------------------------------------
if [ "$COMMERCIAL_USER" = "ask" ]; then
while true; do
echo "Which edition of Qt do you want to use ?"
echo
echo "Type 'c' if you want to use the Commercial Edition."
echo "Type 'o' if you want to use the Open Source Edition."
echo
read commercial
echo
if [ "$commercial" = "c" ]; then
COMMERCIAL_USER="yes"
break
elif [ "$commercial" = "o" ]; then
COMMERCIAL_USER="no"
break
fi
done
fi
if [ -f "$relpath"/LICENSE.PREVIEW.COMMERCIAL ] && [ $COMMERCIAL_USER = "yes" ]; then
# Commercial preview release
Licensee="Preview"
Edition="Preview"
EditionString="Technology Preview"
elif [ $COMMERCIAL_USER = "yes" ]; then
if [ $UNAME_SYSTEM = "Linux" ]; then
case "$PLATFORM" in
*-32)
Licheck=licheck32
;;
*-64)
Licheck=licheck64
;;
*)
if file -L /bin/sh | grep -q "64-bit" ; then
Licheck=licheck64
else
Licheck=licheck32
fi
;;
esac
elif [ $UNAME_SYSTEM = "Darwin" ]; then
Licheck=licheck_mac
else
echo >&2 "Host operating system not supported by this edition of Qt."
exit 1
fi
if [ -x "$relpath/bin/$Licheck" ]; then
LicheckOutput=`$relpath/bin/$Licheck $OPT_CONFIRM_LICENSE $relpath $outpath\
$PLATFORM $XPLATFORM`
if [ $? -ne 0 ]; then
exit 1
else
eval "$LicheckOutput"
fi
else
echo
echo "Error: This is the Open Source version of Qt."
echo "If you want to use Enterprise features of Qt,"
echo "use the contact form at http://www.qt.io/contact-us"
echo "to purchase a license."
echo
exit 1
fi
elif [ $COMMERCIAL_USER = "no" ]; then
# Open Source edition - may only be used under the terms of the LGPLv3 or GPLv2.
Licensee="Open Source"
Edition="OpenSource"
EditionString="Open Source"
fi
if [ "$Edition" = "OpenSource" ] || [ "$Edition" = "Preview" ]; then
echo
echo "This is the Qt ${EditionString} Edition."
echo
fi
if [ "$Edition" = "OpenSource" ]; then
while true; do
if [ "$CFG_ANDROID_STYLE_ASSETS" = "no" ] || [ "$XPLATFORM_ANDROID" = "no" ]; then
echo "You are licensed to use this software under the terms of"
echo "the GNU Lesser General Public License (LGPL) versions 3."
echo "You are also licensed to use this software under the terms of"
echo "the GNU General Public License (GPL) versions 2."
affix="either"
showGPL2="yes"
else
echo "You are licensed to use this software under the terms of"
echo "the GNU Lesser General Public License (LGPL) versions 3."
showGPL2="no"
affix="the"
fi
echo
if [ "$OPT_CONFIRM_LICENSE" = "yes" ]; then
echo "You have already accepted the terms of the $EditionString license."
acceptance=yes
else
if [ -f "$relpath/LICENSE.LGPL3" ]; then
echo "Type 'L' to view the GNU Lesser General Public License version 3."
fi
if [ "$showGPL2" = "yes" ]; then
echo "Type 'G' to view the GNU General Public License version 2."
fi
echo "Type 'yes' to accept this license offer."
echo "Type 'no' to decline this license offer."
echo
echo $ECHO_N "Do you accept the terms of $affix license? $ECHO_C"
read acceptance
fi
echo
if [ "$acceptance" = "yes" ] || [ "$acceptance" = "y" ]; then
break
elif [ "$acceptance" = "no" ]; then
echo "You are not licensed to use this software."
echo
exit 1
elif [ "$acceptance" = "L" ]; then
more "$relpath/LICENSE.LGPL3"
elif [ "$acceptance" = "G" ] && [ "$showGPL2" = "yes" ]; then
more "$relpath/LICENSE.GPL2"
fi
done
elif [ "$Edition" = "Preview" ]; then
TheLicense=`head -n 1 "$relpath/LICENSE.PREVIEW.COMMERCIAL"`
while true; do
if [ "$OPT_CONFIRM_LICENSE" = "yes" ]; then
echo "You have already accepted the terms of the $EditionString license."
acceptance=yes
else
echo "You are licensed to use this software under the terms of"
echo "the $TheLicense"
echo
echo "Type '?' to read the Preview License."
echo "Type 'yes' to accept this license offer."
echo "Type 'no' to decline this license offer."
echo
echo $ECHO_N "Do you accept the terms of the license? $ECHO_C"
read acceptance
fi
echo
if [ "$acceptance" = "yes" ]; then
break
elif [ "$acceptance" = "no" ] ;then
echo "You are not licensed to use this software."
echo
exit 0
elif [ "$acceptance" = "?" ]; then
more "$relpath/LICENSE.PREVIEW.COMMERCIAL"
fi
done
fi
#-------------------------------------------------------------------------------
# command line and environment validation
#-------------------------------------------------------------------------------
if [ "$XPLATFORM_ANDROID" != "no" ]; 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 [ -d "$CFG_DEFAULT_ANDROID_NDK_ROOT/toolchains/arm-linux-androideabi-$CFG_DEFAULT_ANDROID_NDK_TOOLCHAIN_VERSION/prebuilt/darwin-x86_64" ]; then
CFG_DEFAULT_ANDROID_NDK_HOST=darwin-x86_64
fi
;;
win32-*)
CFG_DEFAULT_ANDROID_NDK_HOST=windows
if [ -d "$CFG_DEFAULT_ANDROID_NDK_ROOT/toolchains/arm-linux-androideabi-$CFG_DEFAULT_ANDROID_NDK_TOOLCHAIN_VERSION/prebuilt/windows-x86_64" ]; then
CFG_DEFAULT_ANDROID_NDK_HOST=windows-x86_64
fi
;;
esac
fi
if [ -z "$CFG_DEFAULT_ANDROID_NDK_ROOT" ]; then
echo
echo "Can not find Android NDK. Please use -android-ndk option to specify one"
exit 1
fi
if [ -z "$CFG_DEFAULT_ANDROID_SDK_ROOT" ]; then
echo
echo "Can not find Android SDK. Please use -android-sdk option to specify one"
exit 1
fi
if [ -z "CFG_DEFAULT_ANDROID_NDK_TOOLCHAIN_VERSION" ] || [ ! -d "$CFG_DEFAULT_ANDROID_NDK_ROOT/toolchains/arm-linux-androideabi-$CFG_DEFAULT_ANDROID_NDK_TOOLCHAIN_VERSION/prebuilt" ]; then
echo
echo "Can not detect Android NDK toolchain. Please use -android-toolchain-version to specify"
exit 1
fi
if [ -z "$CFG_DEFAULT_ANDROID_NDK_HOST" ] || [ ! -d "$CFG_DEFAULT_ANDROID_NDK_ROOT/toolchains/arm-linux-androideabi-$CFG_DEFAULT_ANDROID_NDK_TOOLCHAIN_VERSION/prebuilt/$CFG_DEFAULT_ANDROID_NDK_HOST" ]; then
echo
echo "Can not detect the android host. Please use -android-ndk-host option to specify one"
exit 1
fi
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 [ "$BUILD_ON_MAC" = "yes" ]; then
if [ `basename $QMAKESPEC` = "macx-xcode" ] || [ `basename $XQMAKESPEC` = "macx-xcode" ]; then
echo >&2
echo " Platform 'macx-xcode' should not be used when building Qt/Mac." >&2
echo " Please build Qt/Mac with 'macx-clang' or 'macx-g++', then use" >&2
echo " the 'macx-xcode' spec for your application, and it will link to" >&2
echo " the Qt/Mac build using the settings of the original mkspec." >&2
echo >&2
exit 2
fi
fi
# check specified platforms are supported
if [ '!' -d "$QMAKESPEC" ]; then
echo
echo " The specified system/compiler is not supported:"
echo
echo " $QMAKESPEC"
echo
echo " Please see the README file for a complete list."
echo
exit 2
fi
if [ '!' -d "$XQMAKESPEC" ]; then
echo
echo " The specified system/compiler is not supported:"
echo
echo " $XQMAKESPEC"
echo
echo " Please see the README file for a complete list."
echo
exit 2
fi
if [ '!' -f "${XQMAKESPEC}/qplatformdefs.h" ]; then
echo
echo " The specified system/compiler port is not complete:"
echo
echo " $XQMAKESPEC/qplatformdefs.h"
echo
echo " Please information use the contact form at http://www.qt.io/contact-us"
echo
exit 2
fi
#-------------------------------------------------------------------------------
# build tree initialization
#-------------------------------------------------------------------------------
# is this a shadow build?
if [ "$OPT_SHADOW" = "maybe" ]; then
OPT_SHADOW=no
if [ "$relpath" != "$outpath" ] && [ '!' -f "$outpath/configure" ]; then
if [ -h "$outpath" ]; then
[ "$relpath" -ef "$outpath" ] || OPT_SHADOW=yes
else
OPT_SHADOW=yes
fi
fi
fi
if [ "$OPT_SHADOW" = "yes" ]; then
if [ -f "$relpath/.qmake.cache" -o -f "$relpath/src/corelib/global/qconfig.h" -o -f "$relpath/src/corelib/global/qconfig.cpp" ]; then
echo >&2 "You cannot make a shadow build from a source tree containing a previous build."
echo >&2 "Cannot proceed."
exit 1
fi
[ "$OPT_VERBOSE" = "yes" ] && echo "Performing shadow build..."
fi
# if the source tree is different from the build tree,
# symlink or copy part of the sources
if [ "$OPT_SHADOW" = "yes" ]; then
echo "Preparing build tree..."
[ -d "$outpath/bin" ] || mkdir -p "$outpath/bin"
mkdir -p "$outpath/mkspecs"
fi
if [ "$XPLATFORM_ANDROID" = "no" ]; then
TEST_COMPILER=`getXQMakeConf QMAKE_CXX`
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
fi
#-------------------------------------------------------------------------------
# postprocess installation and deployment paths
#-------------------------------------------------------------------------------
if [ -z "$QT_INSTALL_PREFIX" ]; then
if [ "$CFG_DEV" = "yes" ]; then
QT_INSTALL_PREFIX="$outpath" # In Development, we use sandboxed builds by default
else
QT_INSTALL_PREFIX="/usr/local/Qt-${QT_VERSION}" # the default install prefix is /usr/local/Qt-$QT_VERSION
fi
fi
QT_INSTALL_PREFIX=`makeabs "$QT_INSTALL_PREFIX"`
if [ -z "$QT_EXT_PREFIX" ]; then
QT_EXT_PREFIX=$QT_INSTALL_PREFIX
if [ -n "$CFG_SYSROOT" ]; then
QMAKE_SYSROOTIFY=true
else
QMAKE_SYSROOTIFY=false
fi
else
QT_EXT_PREFIX=`makeabs "$QT_EXT_PREFIX"`
QMAKE_SYSROOTIFY=false
fi
if [ -z "$QT_HOST_PREFIX" ]; then
if $QMAKE_SYSROOTIFY; then
QT_HOST_PREFIX=$CFG_SYSROOT$QT_EXT_PREFIX
else
QT_HOST_PREFIX=$QT_EXT_PREFIX
fi
HAVE_HOST_PATH=false
else
QT_HOST_PREFIX=`makeabs "$QT_HOST_PREFIX"`
HAVE_HOST_PATH=true
fi
#------- make the paths relative to the prefixes --------
PREFIX_COMPLAINTS=
PREFIX_REMINDER=false
while read basevar baseoption var option; do
eval path=\$QT_${basevar}_$var
[ -z "$path" ] && continue
path=`makeabs "$path"`
eval base=\$QT_${basevar}_PREFIX
rel=${path##$base}
if [ x"$rel" = x"$path" ]; then
if [ x"$option" != x"sysconf" ]; then
PREFIX_COMPLAINTS="$PREFIX_COMPLAINTS
NOTICE: -${option}dir is not a subdirectory of ${baseoption}prefix."
eval \$HAVE_${basevar}_PATH || PREFIX_REMINDER=true
fi
eval QT_REL_${basevar}_$var=\$rel
elif [ -z "$rel" ]; then
eval QT_REL_${basevar}_$var=.
else
eval QT_REL_${basevar}_$var=\${rel#/}
fi
done <<EOF
INSTALL - DOCS doc
INSTALL - HEADERS header
INSTALL - LIBS lib
INSTALL - LIBEXECS libexec
INSTALL - BINS bin
INSTALL - PLUGINS plugin
INSTALL - IMPORTS import
INSTALL - QML qml
INSTALL - ARCHDATA archdata
INSTALL - DATA data
INSTALL - TRANSLATIONS translation
INSTALL - EXAMPLES examples
INSTALL - TESTS tests
INSTALL - SETTINGS sysconf
HOST -host BINS hostbin
HOST -host LIBS hostlib
HOST -host DATA hostdata
EOF
$PREFIX_REMINDER && PREFIX_COMPLAINTS="$PREFIX_COMPLAINTS
Maybe you forgot to specify -prefix/-hostprefix?"
if [ -z "$QT_REL_INSTALL_HEADERS" ]; then
QT_REL_INSTALL_HEADERS=include
fi
if [ -z "$QT_REL_INSTALL_LIBS" ]; then
QT_REL_INSTALL_LIBS=lib
fi
if [ -z "$QT_REL_INSTALL_BINS" ]; then
QT_REL_INSTALL_BINS=bin
fi
if [ -z "$QT_REL_INSTALL_ARCHDATA" ]; then
QT_REL_INSTALL_ARCHDATA=.
fi
if [ x"$QT_REL_INSTALL_ARCHDATA" != x. ]; then
QT_REL_INSTALL_ARCHDATA_PREFIX=$QT_REL_INSTALL_ARCHDATA/
fi
if [ -z "$QT_REL_INSTALL_LIBEXECS" ]; then
if [ "$XPLATFORM_MINGW" = "yes" ]; then
QT_REL_INSTALL_LIBEXECS=${QT_REL_INSTALL_ARCHDATA_PREFIX}bin
else
QT_REL_INSTALL_LIBEXECS=${QT_REL_INSTALL_ARCHDATA_PREFIX}libexec
fi
fi
if [ -z "$QT_REL_INSTALL_PLUGINS" ]; then
QT_REL_INSTALL_PLUGINS=${QT_REL_INSTALL_ARCHDATA_PREFIX}plugins
fi
if [ -z "$QT_REL_INSTALL_IMPORTS" ]; then
QT_REL_INSTALL_IMPORTS=${QT_REL_INSTALL_ARCHDATA_PREFIX}imports
fi
if [ -z "$QT_REL_INSTALL_QML" ]; then
QT_REL_INSTALL_QML=${QT_REL_INSTALL_ARCHDATA_PREFIX}qml
fi
if [ -z "$QT_REL_INSTALL_DATA" ]; then
QT_REL_INSTALL_DATA=.
fi
if [ x"$QT_REL_INSTALL_DATA" != x. ]; then
QT_REL_INSTALL_DATA_PREFIX=$QT_REL_INSTALL_DATA/
fi
if [ -z "$QT_REL_INSTALL_DOCS" ]; then
QT_REL_INSTALL_DOCS=${QT_REL_INSTALL_DATA_PREFIX}doc
fi
if [ -z "$QT_REL_INSTALL_TRANSLATIONS" ]; then
QT_REL_INSTALL_TRANSLATIONS=${QT_REL_INSTALL_DATA_PREFIX}translations
fi
if [ -z "$QT_REL_INSTALL_EXAMPLES" ]; then
QT_REL_INSTALL_EXAMPLES=examples
fi
if [ -z "$QT_REL_INSTALL_TESTS" ]; then
QT_REL_INSTALL_TESTS=tests
fi
if [ -z "$QT_REL_INSTALL_SETTINGS" ]; then
if [ "$XPLATFORM_MAC" = "yes" ]; then
QT_REL_INSTALL_SETTINGS=/Library/Preferences/Qt
else
QT_REL_INSTALL_SETTINGS=etc/xdg
fi
fi
#------- host paths --------
if [ -z "$QT_REL_HOST_BINS" ]; then
if $HAVE_HOST_PATH; then
QT_REL_HOST_BINS=bin
else
QT_REL_HOST_BINS=$QT_REL_INSTALL_BINS
fi
fi
if [ -z "$QT_REL_HOST_LIBS" ]; then
if $HAVE_HOST_PATH; then
QT_REL_HOST_LIBS=lib
else
QT_REL_HOST_LIBS=$QT_REL_INSTALL_LIBS
fi
fi
if [ -z "$QT_REL_HOST_DATA" ]; then
if $HAVE_HOST_PATH; then
QT_REL_HOST_DATA=.
else
QT_REL_HOST_DATA=$QT_REL_INSTALL_ARCHDATA
fi
fi
shortxspec=`echo $XQMAKESPEC | sed "s,^${relpath}/mkspecs/,,"`
shortspec=`echo $QMAKESPEC | sed "s,^${relpath}/mkspecs/,,"`
QT_CONFIGURE_STR_OFF=0
addConfStr()
{
QT_CONFIGURE_STR_OFFSETS="$QT_CONFIGURE_STR_OFFSETS $QT_CONFIGURE_STR_OFF,"
QT_CONFIGURE_STRS="$QT_CONFIGURE_STRS \"$1\\0\"
"
count=`echo "$1" | wc -c`
QT_CONFIGURE_STR_OFF=`expr $QT_CONFIGURE_STR_OFF + $count`
}
QT_CONFIGURE_STR_OFFSETS=
QT_CONFIGURE_STRS=
addConfStr "$QT_REL_INSTALL_DOCS"
addConfStr "$QT_REL_INSTALL_HEADERS"
addConfStr "$QT_REL_INSTALL_LIBS"
addConfStr "$QT_REL_INSTALL_LIBEXECS"
addConfStr "$QT_REL_INSTALL_BINS"
addConfStr "$QT_REL_INSTALL_PLUGINS"
addConfStr "$QT_REL_INSTALL_IMPORTS"
addConfStr "$QT_REL_INSTALL_QML"
addConfStr "$QT_REL_INSTALL_ARCHDATA"
addConfStr "$QT_REL_INSTALL_DATA"
addConfStr "$QT_REL_INSTALL_TRANSLATIONS"
addConfStr "$QT_REL_INSTALL_EXAMPLES"
addConfStr "$QT_REL_INSTALL_TESTS"
QT_CONFIGURE_STR_OFFSETS_ALL=$QT_CONFIGURE_STR_OFFSETS
QT_CONFIGURE_STRS_ALL=$QT_CONFIGURE_STRS
QT_CONFIGURE_STR_OFFSETS=
QT_CONFIGURE_STRS=
addConfStr "$CFG_SYSROOT"
addConfStr "$QT_REL_HOST_BINS"
addConfStr "$QT_REL_HOST_LIBS"
addConfStr "$QT_REL_HOST_DATA"
addConfStr "$shortxspec"
addConfStr "$shortspec"
#-------------------------------------------------------------------------------
# generate qconfig.cpp
#-------------------------------------------------------------------------------
[ -d "$outpath/src/corelib/global" ] || mkdir -p "$outpath/src/corelib/global"
cat > "$outpath/src/corelib/global/qconfig.cpp.new" <<EOF
/* Installation date */
static const char qt_configure_installation [12+11] = "qt_instdate=2012-12-20";
/* Installation Info */
static const char qt_configure_prefix_path_str [256 + 12] = "qt_prfxpath=$QT_INSTALL_PREFIX";
#ifdef QT_BUILD_QMAKE
static const char qt_configure_ext_prefix_path_str [256 + 12] = "qt_epfxpath=$QT_EXT_PREFIX";
static const char qt_configure_host_prefix_path_str [256 + 12] = "qt_hpfxpath=$QT_HOST_PREFIX";
#endif
static const short qt_configure_str_offsets[] = {
$QT_CONFIGURE_STR_OFFSETS_ALL
#ifdef QT_BUILD_QMAKE
$QT_CONFIGURE_STR_OFFSETS
#endif
};
static const char qt_configure_strs[] =
$QT_CONFIGURE_STRS_ALL#ifdef QT_BUILD_QMAKE
$QT_CONFIGURE_STRS#endif
;
#define QT_CONFIGURE_SETTINGS_PATH "$QT_REL_INSTALL_SETTINGS"
#ifdef QT_BUILD_QMAKE
# define QT_CONFIGURE_SYSROOTIFY_PREFIX $QMAKE_SYSROOTIFY
#endif
#define QT_CONFIGURE_PREFIX_PATH qt_configure_prefix_path_str + 12
#ifdef QT_BUILD_QMAKE
# define QT_CONFIGURE_EXT_PREFIX_PATH qt_configure_ext_prefix_path_str + 12
# define QT_CONFIGURE_HOST_PREFIX_PATH qt_configure_host_prefix_path_str + 12
#endif
EOF
# avoid unecessary rebuilds by copying only if qconfig.cpp has changed
if cmp -s "$outpath/src/corelib/global/qconfig.cpp" "$outpath/src/corelib/global/qconfig.cpp.new"; then
rm -f "$outpath/src/corelib/global/qconfig.cpp.new"
else
[ -f "$outpath/src/corelib/global/qconfig.cpp" ] && chmod +w "$outpath/src/corelib/global/qconfig.cpp"
mv "$outpath/src/corelib/global/qconfig.cpp.new" "$outpath/src/corelib/global/qconfig.cpp"
chmod -w "$outpath/src/corelib/global/qconfig.cpp"
fi
# -----------------------------------------------------------------------------
# build qmake
# -----------------------------------------------------------------------------
# symlink includes
if [ -e "$relpath/.git" ]; then
if [ -z "$PERL" ]; then
echo
echo "You need perl in your PATH to make a build from GIT."
echo "Cannot proceed."
exit 1
fi
"$relpath/bin/syncqt.pl" -version $QT_VERSION -minimal -module QtCore "$relpath" || exit 1
fi
# $1: input variable name (awk regexp)
# $2: optional output variable name
# $3: optional value transformation (sed command)
# relies on $QMAKESPEC, $COMPILER_CONF and $mkfile being set correctly, as the latter
# is where the resulting variable is written to
setBootstrapVariable()
{
getQMakeConf "$1" | echo ${2-$1} = `if [ -n "$3" ]; then sed "$3"; else cat; fi` >> "$mkfile"
}
# build qmake
if true; then ###[ '!' -f "$outpath/bin/qmake" ];
echo "Creating qmake..."
mkdir -p "$outpath/qmake" || exit
# fix makefiles
for mkfile in GNUmakefile Makefile; do
EXTRA_LFLAGS=
EXTRA_CFLAGS=
in_mkfile="${mkfile}.in"
if [ "$mkfile" = "Makefile" ]; then
# if which qmake >/dev/null 2>&1 && [ -f qmake/qmake.pro ]; then
# (cd qmake && qmake) >/dev/null 2>&1 && continue
# fi
in_mkfile="${mkfile}.unix"
fi
in_mkfile="$relpath/qmake/$in_mkfile"
mkfile="$outpath/qmake/$mkfile"
if [ -f "$mkfile" ]; then
[ "$CFG_DEV" = "yes" ] && "$WHICH" chflags >/dev/null 2>&1 && chflags nouchg "$mkfile"
rm -f "$mkfile"
fi
[ -f "$in_mkfile" ] || continue
echo "########################################################################" > "$mkfile"
echo "## This file was autogenerated by configure, all changes will be lost ##" >> "$mkfile"
echo "########################################################################" >> "$mkfile"
EXTRA_OBJS=
EXTRA_SRCS=
EXTRA_CFLAGS="\$(QMAKE_CFLAGS) \$(QMAKE_CFLAGS_SPLIT_SECTIONS)"
EXTRA_CXXFLAGS="\$(QMAKE_CXXFLAGS) \$(QMAKE_CXXFLAGS_CXX11) \$(QMAKE_CXXFLAGS_SPLIT_SECTIONS)"
EXTRA_LFLAGS="\$(QMAKE_LFLAGS) \$(QMAKE_LFLAGS_GCSECTIONS)"
if [ "$PLATFORM" = "irix-cc" ] || [ "$PLATFORM" = "irix-cc-64" ]; then
EXTRA_LFLAGS="$EXTRA_LFLAGS -lm"
fi
[ "$CFG_SILENT" = "yes" ] && CC_TRANSFORM='s,^,\@,' || CC_TRANSFORM=
setBootstrapVariable QMAKE_CC CC "$CC_TRANSFORM"
setBootstrapVariable QMAKE_CXX CXX "$CC_TRANSFORM"
setBootstrapVariable QMAKE_CFLAGS
setBootstrapVariable QMAKE_CFLAGS_SPLIT_SECTIONS
setBootstrapVariable QMAKE_CXXFLAGS
setBootstrapVariable QMAKE_CXXFLAGS_CXX11
setBootstrapVariable QMAKE_CXXFLAGS_SPLIT_SECTIONS
setBootstrapVariable QMAKE_LFLAGS
setBootstrapVariable QMAKE_LFLAGS_GCSECTIONS
if [ "$CFG_DEBUG" = "no" ] || [ "$CFG_RELEASE_TOOLS" = "yes" ]; then
setBootstrapVariable QMAKE_CFLAGS_RELEASE
setBootstrapVariable QMAKE_CXXFLAGS_RELEASE
EXTRA_CFLAGS="$EXTRA_CFLAGS \$(QMAKE_CFLAGS_RELEASE)"
EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS \$(QMAKE_CXXFLAGS_RELEASE)"
else
setBootstrapVariable QMAKE_CFLAGS_DEBUG
setBootstrapVariable QMAKE_CXXFLAGS_DEBUG
EXTRA_CFLAGS="$EXTRA_CFLAGS \$(QMAKE_CFLAGS_DEBUG)"
EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS \$(QMAKE_CXXFLAGS_DEBUG)"
fi
case `basename "$PLATFORM"` in
win32-g++*)
EXTRA_CFLAGS="$EXTRA_CFLAGS -DUNICODE"
EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS -DUNICODE"
EXTRA_OBJS="qfilesystemengine_win.o \
qfilesystemiterator_win.o \
qfsfileengine_win.o \
qlocale_win.o \
qsettings_win.o \
qsystemlibrary.o \
registry.o"
EXTRA_SRCS="\"\$(SOURCE_PATH)/src/corelib/corelib/io/qfilesystemengine_win.cpp\" \
\"\$(SOURCE_PATH)/src/corelib/io/qfilesystemiterator_win.cpp\" \
\"\$(SOURCE_PATH)/src/corelib/io/qfsfileengine_win.cpp\" \
\"\$(SOURCE_PATH)/src/corelib/io/qsettings_win.cpp\" \
\"\$(SOURCE_PATH)/src/corelib/tools/qlocale_win.cpp\" \
\"\$(SOURCE_PATH)/src/corelib/plugin/qsystemlibrary.cpp\" \
\"\$(SOURCE_PATH)/tools/shared/windows/registry.cpp\""
EXTRA_LFLAGS="$EXTRA_LFLAGS -static -s -lole32 -luuid -ladvapi32 -lkernel32"
EXEEXT=".exe"
;;
*)
EXTRA_OBJS="qfilesystemengine_unix.o \
qfilesystemiterator_unix.o \
qfsfileengine_unix.o \
qlocale_unix.o"
EXTRA_SRCS="\"\$(SOURCE_PATH)/src/corelib/io/qfilesystemengine_unix.cpp\" \
\"\$(SOURCE_PATH)/src/corelib/io/qfilesystemiterator_unix.cpp\" \
\"\$(SOURCE_PATH)/src/corelib/io/qfsfileengine_unix.cpp\" \
\"\$(SOURCE_PATH)/src/corelib/tools/qlocale_unix.cpp\""
EXEEXT=
;;
esac
if [ "$BUILD_ON_MAC" = "yes" ]; then
echo "COCOA_LFLAGS =-framework Foundation -framework CoreServices" >>"$mkfile"
echo "CARBON_LFLAGS =-framework ApplicationServices" >>"$mkfile"
echo "CARBON_CFLAGS =-fconstant-cfstrings" >>"$mkfile"
EXTRA_LFLAGS="$EXTRA_LFLAGS \$(COCOA_LFLAGS)"
EXTRA_LFLAGS="$EXTRA_LFLAGS \$(CARBON_LFLAGS)"
EXTRA_CFLAGS="$EXTRA_CFLAGS \$(CARBON_CFLAGS)"
EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS \$(CARBON_CFLAGS)"
EXTRA_OBJS="$EXTRA_OBJS \
qsettings_mac.o \
qcore_mac.o \
qcore_mac_objc.o"
EXTRA_SRCS="$EXTRA_SRCS \
\"\$(SOURCE_PATH)/src/corelib/io/qsettings_mac.cpp\" \
\"\$(SOURCE_PATH)/src/corelib/kernel/qcore_mac.cpp\" \
\"\$(SOURCE_PATH)/src/corelib/kernel/qcore_mac_objc.mm\""
fi
echo >>"$mkfile"
adjrelpath=`echo "$relpath" | sed 's/ /\\\\\\\\ /g'`
adjoutpath=`echo "$outpath" | sed 's/ /\\\\\\\\ /g'`
adjqmakespec=`echo "$QMAKESPEC" | sed 's/ /\\\\\\\\ /g'`
echo "BUILD_PATH = .." >> "$mkfile"
echo "SOURCE_PATH = $adjrelpath" >> "$mkfile"
if [ -e "$relpath/.git" ]; then
echo 'INC_PATH = $(BUILD_PATH)/include' >> "$mkfile"
else
echo 'INC_PATH = $(SOURCE_PATH)/include' >> "$mkfile"
fi
echo "QMAKESPEC = $adjqmakespec" >> "$mkfile"
echo "QT_VERSION = $QT_VERSION" >> "$mkfile"
echo "QT_MAJOR_VERSION = $QT_MAJOR_VERSION" >> "$mkfile"
echo "QT_MINOR_VERSION = $QT_MINOR_VERSION" >> "$mkfile"
echo "QT_PATCH_VERSION = $QT_PATCH_VERSION" >> "$mkfile"
echo "EXTRA_CFLAGS = $EXTRA_CFLAGS" >> "$mkfile"
echo "EXTRA_CXXFLAGS = $EXTRA_CXXFLAGS" >> "$mkfile"
echo "QTOBJS =" $EXTRA_OBJS >> "$mkfile"
echo "QTSRCS =" $EXTRA_SRCS >> "$mkfile"
echo "LFLAGS = $EXTRA_LFLAGS" >> "$mkfile"
echo "EXEEXT = $EXEEXT" >> "$mkfile"
echo "RM_F = rm -f" >> "$mkfile"
echo "RM_RF = rm -rf" >> "$mkfile"
if [ "$BUILD_ON_MAC" = "yes" ]; then
echo "EXTRA_CXXFLAGS += -MMD" >> "$mkfile"
cat "$in_mkfile" >> "$mkfile"
echo "-include \$(notdir \$(DEPEND_SRC:%.cpp=%.d))" >> "$mkfile"
else
cat "$in_mkfile" >> "$mkfile"
if "$WHICH" makedepend >/dev/null 2>&1 && grep 'depend:' "$mkfile" >/dev/null 2>&1; then
(cd "$outpath/qmake" && "$MAKE" -f "$mkfile" depend) >/dev/null 2>&1
sed 's,^.*/\([^/]*.o\):,\1:,g' "$mkfile" >"$mkfile.tmp"
sed "s,$outpath,$adjoutpath,g" "$mkfile.tmp" >"$mkfile"
rm "$mkfile.tmp"
fi
fi
done
if [ "$OPT_VERBOSE" = yes ]; then
# Show the output of make
(cd "$outpath/qmake"; "$MAKE") || exit 2
else
# Hide the output of make
# Use bash to print dots, if we have it, and stdout is a tty.
if test -t 1 && $WHICH bash > /dev/null 2>/dev/null; then
bash -c 'set -o pipefail
cd "$0/qmake"; "$1" | while read line; do
builtin echo -n .
done' "$outpath" "$MAKE" || exit 2
else
(cd "$outpath/qmake"; "$MAKE" -s) || exit 2
fi
echo "Done."
fi
fi # Build qmake
#-------------------------------------------------------------------------------
# create a qt.conf for the Qt build tree itself
#-------------------------------------------------------------------------------
QTCONFFILE="$outpath/bin/qt.conf"
cat > "$QTCONFFILE" <<EOF
[EffectivePaths]
Prefix=..
EOF
if [ -n "$CFG_HOST_QT_TOOLS_PATH" ]; then
cat >> "$QTCONFFILE" <<EOF
[Paths]
Prefix=$QT_EXT_PREFIX
Documentation=$QT_REL_INSTALL_DOCS
Headers=$QT_REL_INSTALL_HEADERS
Libraries=$QT_REL_INSTALL_LIBS
LibraryExecutables=$QT_REL_INSTALL_LIBEXECS
Binaries=$QT_REL_INSTALL_BINS
Plugins=$QT_REL_INSTALL_PLUGINS
Imports=$QT_REL_INSTALL_IMPORTS
Qml2Imports=$QT_REL_INSTALL_QML
ArchData=$QT_REL_INSTALL_ARCHDATA
Data=$QT_REL_INSTALL_DATA
Translations=$QT_REL_INSTALL_TRANSLATIONS
Examples=$QT_REL_INSTALL_EXAMPLES
Tests=$QT_REL_INSTALL_TESTS
HostPrefix=$QT_HOST_PREFIX
HostBinaries=$QT_REL_HOST_BINS
HostLibraries=$QT_REL_HOST_LIBS
HostData=$QT_REL_HOST_DATA
TargetSpec=$XPLATFORM
HostSpec=$PLATFORM
EOF
if [ -n "$CFG_SYSROOT" ]; then
cat >> "$QTCONFFILE" <<EOF
Sysroot=$CFG_SYSROOT
EOF
fi
fi
if [ x"$relpath" != x"$outpath" ]; then
cat >> "$QTCONFFILE" <<EOF
[EffectiveSourcePaths]
Prefix=$relpath
EOF
fi
[ -z "$CFG_HOST_QT_TOOLS_PATH" ] && CFG_HOST_QT_TOOLS_PATH="$outpath/bin"
CFG_QMAKE_PATH="$CFG_HOST_QT_TOOLS_PATH/qmake"
#-------------------------------------------------------------------------------
# write out device config before we run the test.
#-------------------------------------------------------------------------------
DEVICE_VARS_OUTFILE="$outpath/mkspecs/qdevice.pri"
if cmp -s "$DEVICE_VARS_FILE" "$DEVICE_VARS_OUTFILE"; then
rm -f "$DEVICE_VARS_FILE"
else
mv -f $DEVICE_VARS_FILE "$DEVICE_VARS_OUTFILE"
DEVICE_VARS_FILE="$DEVICE_VARS_OUTFILE"
fi
#-------------------------------------------------------------------------------
# write out host config.
#-------------------------------------------------------------------------------
HOST_VARS_OUTFILE="$outpath/mkspecs/qhost.pri"
if cmp -s "$HOST_VARS_FILE" "$HOST_VARS_OUTFILE"; then
rm -f "$HOST_VARS_FILE"
else
mv -f $HOST_VARS_FILE "$HOST_VARS_OUTFILE"
HOST_VARS_FILE="$HOST_VARS_OUTFILE"
fi
#-------------------------------------------------------------------------------
# run configure tests
#-------------------------------------------------------------------------------
# copy some variables that are still being computed in the shell script into an input file for configure
# This should go away in the future
cat > "$outpath/config.tests/configure.cfg" <<EOF
# Feature defaults set by configure command line
config.input.extra_features = $CFG_FEATURES
config.input.qt_edition = $Edition
config.input.qt_licheck = $Licheck
config.input.qt_release_date = $ReleaseDate
EOF
# create a clean qmodule/qconfig.pri for running the tests
# .qmake.cache loads qt_build_parts which requires that qmodule.pri exists
for arg in qconfig qmodule; do
file="$outpath/mkspecs/$arg.pri"
[ ! -f "$file.old" ] && [ -f "$file" ] && mv "$file" "$file.old"
: > "$file"
done
# recreate command line for qmake
set -f
SAVED_IFS=$IFS
IFS='
'
for i in $QMAKE_CMDLINE; do
set -- "$@" "$i"
done
set +f
IFS=$SAVED_IFS
# redirect qmake's output to a dummy Makefile
$CFG_QMAKE_PATH -o Makefile.cfg -qtconf "$QTCONFFILE" $relpath/configure.pri -- "$@" || exit 101
rm Makefile.cfg
# Re-use old file if unchanged, to avoid needless rebuilds
for arg in qconfig qmodule; do
file="$outpath/mkspecs/$arg.pri"
if cmp -s "$file" "$file.old"; then
rm -f "$file"
mv "$file.old" "$file"
else
rm -f "$file.old"
fi
done
#-------------------------------------------------------------------------------
# give feedback on configuration
#-------------------------------------------------------------------------------
if [ -n "$PLATFORM_NOTES" ]; then
echo
echo "Platform notes:"
echo "$PLATFORM_NOTES"
else
echo
fi
#-------------------------------------------------------------------------------
# build makefiles based on the configuration
#-------------------------------------------------------------------------------
( # fork to make the cd stay local
relpathMangled=$relpath
if [ -n "$CFG_TOPLEVEL" ]; then
relpathMangled=`dirname "$relpath"`
cd ..
fi
"$CFG_QMAKE_PATH" -qtconf "$QTCONFFILE" "$relpathMangled"
) || exit
#-------------------------------------------------------------------------------
# finally save the executed command to another script
#-------------------------------------------------------------------------------
if [ $CFG_REDO = no ]; then
echo "$OPT_CMDLINE" | grep '\-confirm\-license' >/dev/null 2>&1 || OPT_CMDLINE="$OPT_CMDLINE
-confirm-license"
# skip first line, as it's always empty due to unconditional field separation
echo "$OPT_CMDLINE" | tail -n +2 > "$outpath/config.opt"
[ -f "$outpath/config.status" ] && rm -f "$outpath/config.status"
echo "#!/bin/sh" > "$outpath/config.status"
echo "$relpath/$relconf -redo \"\$@\"" >> "$outpath/config.status"
chmod +x "$outpath/config.status"
fi
if [ -n "$PREFIX_COMPLAINTS" ]; then
echo
echo "$PREFIX_COMPLAINTS"
echo
fi
MAKE=`basename "$MAKE"`
echo
echo Qt is now configured for building. Just run \'$MAKE\'.
if [ "$outpath" = "$QT_INSTALL_PREFIX" ]; then
echo Once everything is built, Qt is installed.
echo You should not run \'$MAKE install\'.
else
echo Once everything is built, you must run \'$MAKE install\'.
echo Qt will be installed into $QT_INSTALL_PREFIX
fi
echo
echo Prior to reconfiguration, make sure you remove any leftovers from
echo the previous build.
echo
Reference in New Issue View Git Blame Copy Permalink