#!/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 # later cache the command line in config.status OPT_CMDLINE= for i in "$@"; do QMAKE_CMDLINE="$QMAKE_CMDLINE $i" if [ "x$i" != "x-v" ]; then [ -z "${i##* *}" ] && i="'$i'" OPT_CMDLINE="$OPT_CMDLINE $i" fi done # initialize global variables QMAKE_VARS_FILE=.qmake.vars DEVICE_VARS_FILE=.device.vars HOST_VARS_FILE=.host.vars :> "$QMAKE_VARS_FILE" :> "$DEVICE_VARS_FILE" :> "$HOST_VARS_FILE" #------------------------------------------------------------------------------- # utility functions #------------------------------------------------------------------------------- makeabs() { local FILE="$1" local RES="$FILE" if [ -z "${FILE##/*}" ]; then true elif [ "$OSTYPE" = "msys" -a -z "${FILE##[a-zA-Z]:[/\\]*}" ]; then true else RES=$PWD/$FILE fi RES=$RES/ while true; do nres=`echo "$RES" | sed 's,/[^/][^/]*/\.\./,/,g; s,/\./,/,g'` test x"$nres" = x"$RES" && break RES=$nres done echo "$RES" | sed 's,//,/,g; s,/$,,' } # Adds a new qmake variable to the cache # Usage: QMakeVar mode varname contents # where mode is one of: set, add, del QMakeVar() { case "$1" in set) eq="=" ;; add) eq="+=" ;; del) eq="-=" ;; *) echo >&2 "BUG: wrong command to QMakeVar: $1" ;; esac echo "$2" "$eq" "$3" >> "$QMAKE_VARS_FILE" } # 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 "$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 HOST_DIRLIST_SEP=":" DEV_NULL=/dev/null if [ "$OSTYPE" = "msys" ]; then HOST_DIRLIST_SEP=";" DEV_NULL=/tmp/empty-file echo "" > $DEV_NULL relpath=`(cd "$relpath"; pwd -W)` outpath=`pwd -W` fi #------------------------------------------------------------------------------- # Verify Xcode installation on Mac OS #------------------------------------------------------------------------------- if [ "$BUILD_ON_MAC" = "yes" ]; then if ! /usr/bin/xcode-select --print-path >/dev/null 2>&1; then echo >&2 echo " No Xcode is selected. Use xcode-select -switch to choose an Xcode" >&2 echo " version. See the xcode-select man page for more information." >&2 echo >&2 exit 2 fi if ! /usr/bin/xcrun -find xcrun >/dev/null 2>&1; then echo >&2 echo " Xcode not set up properly. You may need to confirm the license" >&2 echo " agreement by running /usr/bin/xcodebuild without arguments." >&2 echo >&2 exit 2 fi fi #----------------------------------------------------------------------------- # Qt version detection #----------------------------------------------------------------------------- QT_VERSION= QT_MAJOR_VERSION= QT_MINOR_VERSION=0 QT_PATCH_VERSION=0 eval `sed -n -e 's/^MODULE_VERSION = \(\([0-9]*\)\.\([0-9]*\)\.\([0-9]*\).*\)$/QT_VERSION=\1\ QT_MAJOR_VERSION=\2\ QT_MINOR_VERSION=\3\ QT_PATCH_VERSION=\4/p' < "$relpath"/.qmake.conf` if [ -z "$QT_MAJOR_VERSION" ]; then echo "Cannot process version from .qmake.conf" echo "Cannot proceed." exit 1 fi #------------------------------------------------------------------------------- # initalize variables #------------------------------------------------------------------------------- SYSTEM_VARIABLES="AR RANLIB STRIP OBJDUMP LD CC CXX CFLAGS CXXFLAGS LDFLAGS" for varname in $SYSTEM_VARIABLES; do qmakevarname="${varname}" qmakecmdargs="" # use LDFLAGS for autoconf compat, but qmake uses QMAKE_LFLAGS if [ "${varname}" = "LDFLAGS" ]; then qmakevarname="LFLAGS" elif [ "${varname}" = "LD" ]; then qmakevarname="LINK" elif [ "${varname}" = "AR" ]; then # QMAKE_AR needs to be set to "/path/to/ar cqs" but the # environment variable will be set to the command only so we # need to append " cqs" for autoconf compatibility qmakecmdargs=" cqs" fi cmd=`echo \ 'if [ -n "\$'${varname}'" ]; then QMakeVar set QMAKE_'${qmakevarname}' "\$'${varname}${qmakecmdargs}'" fi'` eval "$cmd" done # Use CC/CXX to run config.tests mkdir -p "$outpath/config.tests" rm -f "$outpath/config.tests/.qmake.cache" cp "$QMAKE_VARS_FILE" "$outpath/config.tests/.qmake.cache" # QTDIR may be set and point to an old or system-wide Qt installation unset QTDIR # initalize internal variables CFG_RELEASE_TOOLS=no QT_ALL_BUILD_PARTS=" libs tools examples tests " QT_DEFAULT_BUILD_PARTS="libs tools examples" CFG_BUILD_PARTS="" CFG_NOBUILD_PARTS="" 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" ;; 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 ;; 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=yes ;; esac #------------------------------------------------------------------------------- # check the license #------------------------------------------------------------------------------- if [ "$COMMERCIAL_USER" = "ask" ]; then while true; do echo "Which edition of Qt do you want to use ?" echo echo "Type 'c' if you want to use the Commercial Edition." echo "Type 'o' if you want to use the Open Source Edition." echo read commercial echo if [ "$commercial" = "c" ]; then COMMERCIAL_USER="yes" break elif [ "$commercial" = "o" ]; then COMMERCIAL_USER="no" break fi done fi if [ -f "$relpath"/LICENSE.PREVIEW.COMMERCIAL ] && [ $COMMERCIAL_USER = "yes" ]; then # Commercial preview release Licensee="Preview" Edition="Preview" EditionString="Technology Preview" elif [ $COMMERCIAL_USER = "yes" ]; then if [ $UNAME_SYSTEM = "Linux" ]; then case "$PLATFORM" in *-32) Licheck=licheck32 ;; *-64) Licheck=licheck64 ;; *) if file -L /bin/sh | grep -q "64-bit" ; then Licheck=licheck64 else Licheck=licheck32 fi ;; esac elif [ $UNAME_SYSTEM = "Darwin" ]; then Licheck=licheck_mac else echo >&2 "Host operating system not supported by this edition of Qt." exit 1 fi if [ -x "$relpath/bin/$Licheck" ]; then LicheckOutput=`$relpath/bin/$Licheck $OPT_CONFIRM_LICENSE $relpath $outpath\ $PLATFORM $XPLATFORM` if [ $? -ne 0 ]; then exit 1 else eval "$LicheckOutput" fi else echo echo "Error: This is the Open Source version of Qt." echo "If you want to use Enterprise features of Qt," echo "use the contact form at http://www.qt.io/contact-us" echo "to purchase a license." echo exit 1 fi elif [ $COMMERCIAL_USER = "no" ]; then # Open Source edition - may only be used under the terms of the LGPLv3 or GPLv2. Licensee="Open Source" Edition="OpenSource" EditionString="Open Source" fi if [ "$Edition" = "OpenSource" ] || [ "$Edition" = "Preview" ]; then echo echo "This is the Qt ${EditionString} Edition." echo fi if [ "$Edition" = "OpenSource" ]; then while true; do if [ "$CFG_ANDROID_STYLE_ASSETS" = "no" ] || [ "$XPLATFORM_ANDROID" = "no" ]; then echo "You are licensed to use this software under the terms of" echo "the GNU Lesser General Public License (LGPL) versions 3." echo "You are also licensed to use this software under the terms of" echo "the GNU General Public License (GPL) versions 2." affix="either" showGPL2="yes" else echo "You are licensed to use this software under the terms of" echo "the GNU Lesser General Public License (LGPL) versions 3." showGPL2="no" affix="the" fi echo if [ "$OPT_CONFIRM_LICENSE" = "yes" ]; then echo "You have already accepted the terms of the $EditionString license." acceptance=yes else if [ -f "$relpath/LICENSE.LGPL3" ]; then echo "Type 'L' to view the GNU Lesser General Public License version 3." fi if [ "$showGPL2" = "yes" ]; then echo "Type 'G' to view the GNU General Public License version 2." fi echo "Type 'yes' to accept this license offer." echo "Type 'no' to decline this license offer." echo echo $ECHO_N "Do you accept the terms of $affix license? $ECHO_C" read acceptance fi echo if [ "$acceptance" = "yes" ] || [ "$acceptance" = "y" ]; then break elif [ "$acceptance" = "no" ]; then echo "You are not licensed to use this software." echo exit 1 elif [ "$acceptance" = "L" ]; then more "$relpath/LICENSE.LGPL3" elif [ "$acceptance" = "G" ] && [ "$showGPL2" = "yes" ]; then more "$relpath/LICENSE.GPL2" fi done elif [ "$Edition" = "Preview" ]; then TheLicense=`head -n 1 "$relpath/LICENSE.PREVIEW.COMMERCIAL"` while true; do if [ "$OPT_CONFIRM_LICENSE" = "yes" ]; then echo "You have already accepted the terms of the $EditionString license." acceptance=yes else echo "You are licensed to use this software under the terms of" echo "the $TheLicense" echo echo "Type '?' to read the Preview License." echo "Type 'yes' to accept this license offer." echo "Type 'no' to decline this license offer." echo echo $ECHO_N "Do you accept the terms of the license? $ECHO_C" read acceptance fi echo if [ "$acceptance" = "yes" ]; then break elif [ "$acceptance" = "no" ] ;then echo "You are not licensed to use this software." echo exit 0 elif [ "$acceptance" = "?" ]; then more "$relpath/LICENSE.PREVIEW.COMMERCIAL" fi done fi #------------------------------------------------------------------------------- # command line and environment validation #------------------------------------------------------------------------------- if [ "$XPLATFORM_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 [ -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_IOS" = "yes" ] || [ "$XPLATFORM_TVOS" = "yes" ]; then CFG_NOBUILD_PARTS="$CFG_NOBUILD_PARTS examples" fi if [ "$XPLATFORM_ANDROID" != "yes" ]; 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 #setup the build parts if [ -z "$CFG_BUILD_PARTS" ]; then CFG_BUILD_PARTS="$QT_DEFAULT_BUILD_PARTS" # build tests by default, if a developer build if [ "$CFG_DEV" = "yes" ]; then CFG_BUILD_PARTS="$CFG_BUILD_PARTS tests" fi # don't build tools by default when cross-compiling if [ "$PLATFORM" != "$XPLATFORM" ]; then CFG_BUILD_PARTS=`echo "$CFG_BUILD_PARTS" | sed 's, tools,,g'` fi fi for nobuild in $CFG_NOBUILD_PARTS; do CFG_BUILD_PARTS=`echo "$CFG_BUILD_PARTS" | sed "s, $nobuild,,g"` done if echo $CFG_BUILD_PARTS | grep -v libs >/dev/null 2>&1; then # echo # echo "WARNING: libs is a required part of the build." # echo CFG_BUILD_PARTS="$CFG_BUILD_PARTS libs" fi #------------------------------------------------------------------------------- # postprocess installation and deployment paths #------------------------------------------------------------------------------- if [ -z "$QT_INSTALL_PREFIX" ]; then if [ "$CFG_DEV" = "yes" ]; then QT_INSTALL_PREFIX="$outpath" # In Development, we use sandboxed builds by default else QT_INSTALL_PREFIX="/usr/local/Qt-${QT_VERSION}" # the default install prefix is /usr/local/Qt-$QT_VERSION fi fi QT_INSTALL_PREFIX=`makeabs "$QT_INSTALL_PREFIX"` if [ -z "$QT_EXT_PREFIX" ]; then QT_EXT_PREFIX=$QT_INSTALL_PREFIX if [ -n "$CFG_SYSROOT" ]; then QMAKE_SYSROOTIFY=true else QMAKE_SYSROOTIFY=false fi else QT_EXT_PREFIX=`makeabs "$QT_EXT_PREFIX"` QMAKE_SYSROOTIFY=false fi if [ -z "$QT_HOST_PREFIX" ]; then if $QMAKE_SYSROOTIFY; then QT_HOST_PREFIX=$CFG_SYSROOT$QT_EXT_PREFIX else QT_HOST_PREFIX=$QT_EXT_PREFIX fi HAVE_HOST_PATH=false else QT_HOST_PREFIX=`makeabs "$QT_HOST_PREFIX"` HAVE_HOST_PATH=true fi #------- make the paths relative to the prefixes -------- PREFIX_COMPLAINTS= PREFIX_REMINDER=false while read basevar baseoption var option; do eval path=\$QT_${basevar}_$var [ -z "$path" ] && continue path=`makeabs "$path"` eval base=\$QT_${basevar}_PREFIX rel=${path##$base} if [ x"$rel" = x"$path" ]; then if [ x"$option" != x"sysconf" ]; then PREFIX_COMPLAINTS="$PREFIX_COMPLAINTS NOTICE: -${option}dir is not a subdirectory of ${baseoption}prefix." eval \$HAVE_${basevar}_PATH || PREFIX_REMINDER=true fi eval QT_REL_${basevar}_$var=\$rel elif [ -z "$rel" ]; then eval QT_REL_${basevar}_$var=. else eval QT_REL_${basevar}_$var=\${rel#/} fi done < "$outpath/src/corelib/global/qconfig.cpp.new" <> "$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" <> "$QTCONFFILE" <> "$QTCONFFILE" <> "$QTCONFFILE" < "$outpath/config.tests/configure.cfg" < "$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 if [ "$OPT_VERBOSE" = "yes" ]; then echo $ECHO_N "qmake vars .......... $ECHO_C" cat "$QMAKE_VARS_FILE" | tr '\n' ' ' echo fi sepath=`echo "$relpath" | sed -e 's/\\./\\\\./g'` PROCS=1 EXEC="" rm -f "$QMAKE_VARS_FILE" 2>/dev/null #------------------------------------------------------------------------------- # build makefiles based on the configuration #------------------------------------------------------------------------------- ( # fork to make the cd stay local relpathMangled=$relpath if [ -n "$CFG_TOPLEVEL" ]; then relpathMangled=`dirname "$relpath"` cd .. fi "$CFG_QMAKE_PATH" -qtconf "$QTCONFFILE" "$relpathMangled" ) || exit #------------------------------------------------------------------------------- # finally save the executed command to another script #------------------------------------------------------------------------------- if [ `basename $0` != "config.status" ]; then CONFIG_STATUS="$relpath/$relconf$OPT_CMDLINE" # add the system variables for varname in $SYSTEM_VARIABLES; do cmd=`echo \ 'if [ -n "\$'${varname}'" ]; then CONFIG_STATUS="'${varname}'='"'\\\$${varname}'"' \$CONFIG_STATUS" fi'` eval "$cmd" done echo "$CONFIG_STATUS" | grep '\-confirm\-license' >/dev/null 2>&1 || CONFIG_STATUS="$CONFIG_STATUS -confirm-license" [ -f "$outpath/config.status" ] && rm -f "$outpath/config.status" echo "#!/bin/sh" > "$outpath/config.status" [ -n "$PKG_CONFIG_SYSROOT_DIR" ] && \ echo "export PKG_CONFIG_SYSROOT_DIR=$PKG_CONFIG_SYSROOT_DIR" >> "$outpath/config.status" [ -n "$PKG_CONFIG_LIBDIR" ] && \ echo "export PKG_CONFIG_LIBDIR=$PKG_CONFIG_LIBDIR" >> "$outpath/config.status" echo "$CONFIG_STATUS \"\$@\"" >> "$outpath/config.status" chmod +x "$outpath/config.status" fi if [ -n "$RPATH_MESSAGE" ]; then echo echo "$RPATH_MESSAGE" fi if [ -n "$PREFIX_COMPLAINTS" ]; then echo echo "$PREFIX_COMPLAINTS" echo fi MAKE=`basename "$MAKE"` echo echo Qt is now configured for building. Just run \'$MAKE\'. if [ "$outpath" = "$QT_INSTALL_PREFIX" ]; then echo Once everything is built, Qt is installed. echo You should not run \'$MAKE install\'. else echo Once everything is built, you must run \'$MAKE install\'. echo Qt will be installed into $QT_INSTALL_PREFIX fi echo echo Prior to reconfiguration, make sure you remove any leftovers from echo the previous build. echo