#!/bin/sh
#############################################################################
##
## Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
## All rights reserved.
## Contact: Nokia Corporation (qt-info@nokia.com)
##
## This file is the build configuration utility of the Qt Toolkit.
##
## $QT_BEGIN_LICENSE:LGPL$
## No Commercial Usage
## This file contains pre-release code and may not be distributed.
## You may use this file in accordance with the terms and conditions
## contained in the Technology Preview License Agreement accompanying
## this package.
##
## GNU Lesser General Public License Usage
## Alternatively, this file may be used under the terms of the GNU Lesser
## General Public License version 2.1 as published by the Free Software
## Foundation and appearing in the file LICENSE.LGPL included in the
## packaging of this file. Please review the following information to
## ensure the GNU Lesser General Public License version 2.1 requirements
## will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
##
## In addition, as a special exception, Nokia gives you certain additional
## rights. These rights are described in the Nokia Qt LGPL Exception
## version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
##
## If you have questions regarding the use of this file, please contact
## Nokia at qt-info@nokia.com.
##
##
##
##
##
##
##
##
## $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`
#license file location
LICENSE_FILE="$QT_LICENSE_FILE"
[ -z "$LICENSE_FILE" ] && LICENSE_FILE="$HOME/.qt-license"
if [ -f "$LICENSE_FILE" ]; then
tr -d '\r' <"$LICENSE_FILE" >"${LICENSE_FILE}.tmp"
diff "${LICENSE_FILE}.tmp" "${LICENSE_FILE}" >/dev/null 2>&1 || LICENSE_FILE="${LICENSE_FILE}.tmp"
fi
# later cache the command line in config.status
OPT_CMDLINE=`echo $@ | sed "s,-v ,,g; s,-v$,,g"`
# initialize global variables
QMAKE_SWITCHES=
QMAKE_VARS=
QMAKE_CONFIG=
QTCONFIG_CONFIG=
QT_CONFIG=
SUPPORTED=
QMAKE_VARS_FILE=.qmake.vars
:> "$QMAKE_VARS_FILE"
#-------------------------------------------------------------------------------
# utility functions
#-------------------------------------------------------------------------------
shellEscape()
{
echo "$@" | sed 's/ /\ /g'
}
# 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"
}
# relies on $QMAKESPEC being set correctly. parses include statements in
# qmake.conf and prints out the expanded file
getQMakeConf()
{
tmpSPEC="$QMAKESPEC"
if [ -n "$1" ]; then
tmpSPEC="$1"
fi
$AWK -v "QMAKESPEC=$tmpSPEC" '
/^include\(.+\)$/{
fname = QMAKESPEC "/" substr($0, 9, length($0) - 9)
while ((getline line < fname) > 0)
print line
close(fname)
next
}
{ print }' "$tmpSPEC/qmake.conf"
}
# relies on $TEST_COMPILER being set correctly
compilerSupportsFlag()
{
cat >conftest.cpp <<EOF
int main() { return 0; }
EOF
"$TEST_COMPILER" "$@" -o /dev/null conftest.cpp
ret=$?
rm -f conftest.cpp conftest.o
return $ret
}
# relies on $TEST_COMPILER being set correctly
linkerSupportsFlag()
{
lflags=-Wl
for flag
do
safe_flag=`shellEscape "$flag"`
lflags=$lflags,$safe_flag
done
compilerSupportsFlag "$lflags" >/dev/null 2>&1
}
#-------------------------------------------------------------------------------
# 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
#-------------------------------------------------------------------------------
# window system detection
#-------------------------------------------------------------------------------
PLATFORM_X11=no
PLATFORM_MAC=no
PLATFORM_QWS=no
PLATFORM_SYMBIAN=no
if [ -f "$relpath"/src/gui/kernel/qapplication_mac.mm ] && [ -d /System/Library/Frameworks/Carbon.framework ]; then
# Qt/Mac
# ~ the Carbon SDK exists
# ~ src/gui/base/qapplication_mac.cpp is present
# ~ this is the internal edition and Qt/Mac sources exist
PLATFORM_MAC=maybe
elif [ -f "$relpath"/src/gui/kernel/qapplication_qws.cpp ]; then
# Qt Embedded
# ~ src/gui/base/qapplication_qws.cpp is present
# ~ this is the free or commercial edition
# ~ this is the internal edition and Qt Embedded is explicitly enabled
if [ -f "$relpath"/src/gui/kernel/qapplication_mac.mm ]; then
# This is a depot build, or an all-platforms package
PLATFORM_QWS=maybe
else
# This must be the embedded package, since the Qt/Mac source files are not present
PLATFORM_QWS=yes
fi
fi
#-----------------------------------------------------------------------------
# Qt version detection
#-----------------------------------------------------------------------------
QT_VERSION=`grep '^# *define *QT_VERSION_STR' "$relpath"/src/corelib/global/qglobal.h`
QT_MAJOR_VERSION=
QT_MINOR_VERSION=0
QT_PATCH_VERSION=0
if [ -n "$QT_VERSION" ]; then
QT_VERSION=`echo $QT_VERSION | sed 's,^# *define *QT_VERSION_STR *"*\([^ ]*\)"$,\1,'`
MAJOR=`echo $QT_VERSION | sed 's,^\([0-9]*\)\.\([0-9]*\)\.\([0-9]*\).*,\1,'`
if [ -n "$MAJOR" ]; then
MINOR=`echo $QT_VERSION | sed 's,^\([0-9]*\)\.\([0-9]*\)\.\([0-9]*\).*,\2,'`
PATCH=`echo $QT_VERSION | sed 's,^\([0-9]*\)\.\([0-9]*\)\.\([0-9]*\).*,\3,'`
QT_MAJOR_VERSION="$MAJOR"
[ -z "$MINOR" ] || QT_MINOR_VERSION="$MINOR"
[ -z "$PATCH" ] || QT_PATCH_VERSION="$PATCH"
fi
fi
if [ -z "$QT_MAJOR_VERSION" ]; then
echo "Cannot process version from qglobal.h: $QT_VERSION"
echo "Cannot proceed."
exit 1
fi
QT_PACKAGEDATE=`grep '^# *define *QT_PACKAGEDATE_STR' "$relpath"/src/corelib/global/qglobal.h | sed -e 's,^# *define *QT_PACKAGEDATE_STR *"\([^ ]*\)"$,\1,' -e s,-,,g`
if [ -z "$QT_PACKAGEDATE" ]; then
echo "Unable to determine package date from qglobal.h: '$QT_PACKAGEDATE'"
echo "Cannot proceed"
exit 1
fi
#-------------------------------------------------------------------------------
# check the license
#-------------------------------------------------------------------------------
COMMERCIAL_USER=ask
#For Symbian building on Linux platform it is supposed only development under Nokia
CFG_DEV=no
CFG_NOKIA=yes
CFG_EMBEDDED=no
EditionString=Commercial
earlyArgParse()
{
# 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
;;
-embedded)
VAR=embedded
# this option may or may not be followed by an argument
if [ -z "$2" ] || echo "$2" | grep '^-' >/dev/null 2>&1; then
VAL=auto
else
shift;
VAL=$1
fi
;;
-h|help|--help|-help)
if [ "$VAL" = "yes" ]; then
OPT_HELP="$VAL"
COMMERCIAL_USER="no" #doesn't matter we will display the help
else
UNKNOWN_OPT=yes
COMMERCIAL_USER="no" #doesn't matter we will display the help
fi
;;
--*)
VAR=`echo $1 | sed "s,^--\(.*\),\1,"`
VAL=yes
;;
-*)
VAR=`echo $1 | sed "s,^-\(.*\),\1,"`
VAL="unknown"
;;
*)
UNKNOWN_ARG=yes
;;
esac
if [ "$UNKNOWN_ARG" = "yes" ]; then
shift
continue
fi
shift
UNKNOWN_OPT=no
case "$VAR" in
embedded)
CFG_EMBEDDED="$VAL"
if [ "$PLATFORM_QWS" != "no" ]; then
if [ "$PLATFORM_QWS" = "maybe" ]; then
PLATFORM_X11=no
PLATFORM_MAC=no
PLATFORM_QWS=yes
fi
else
echo "No license exists to enable Qt for Embedded Linux. Disabling."
CFG_EMBEDDED=no
fi
;;
developer-build)
CFG_DEV="yes"
;;
nokia-developer)
CFG_DEV="yes"
CFG_NOKIA="yes"
COMMERCIAL_USER="no"
;;
commercial)
COMMERCIAL_USER="yes"
;;
opensource)
COMMERCIAL_USER="no"
;;
*)
UNKNOWN_OPT=yes
;;
esac
done
}
earlyArgParse "$@"
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 [ "$CFG_NOKIA" = "yes" ]; then
Licensee="Nokia"
Edition="NokiaInternalBuild"
EditionString="Nokia Internal Build"
QT_EDITION="QT_EDITION_OPENSOURCE"
[ "$PLATFORM_MAC" = "maybe" ] && PLATFORM_MAC=yes
elif [ -f "$relpath"/LICENSE.PREVIEW.COMMERCIAL ] && [ $COMMERCIAL_USER = "yes" ]; then
# Commercial preview release
[ "$PLATFORM_MAC" = "maybe" ] && PLATFORM_MAC=yes
Licensee="Preview"
Edition="Preview"
QT_EDITION="QT_EDITION_DESKTOP"
LicenseType="Technology Preview"
elif [ $COMMERCIAL_USER = "yes" ]; then
# one of commercial editions
[ "$PLATFORM_MAC" = "maybe" ] && PLATFORM_MAC=yes
[ "$PLATFORM_QWS" = "maybe" ] && PLATFORM_QWS=no
# read in the license file
if [ -f "$LICENSE_FILE" ]; then
. "$LICENSE_FILE" >/dev/null 2>&1
if [ -z "$LicenseKeyExt" ]; then
echo
echo "You are using an old license file."
echo
echo "Please install the license file supplied by Nokia,"
echo "or install the Qt Open Source Edition if you intend to"
echo "develop free software."
exit 1
fi
if [ -z "$Licensee" ]; then
echo
echo "Invalid license key. Please check the license key."
exit 1
fi
else
if [ -z "$LicenseKeyExt" ]; then
echo
if echo '\c' | grep '\c' >/dev/null; then
echo -n "Please enter your license key: "
else
echo "Please enter your license key: \c"
fi
read LicenseKeyExt
Licensee="Unknown user"
fi
fi
# Key verification
echo "$LicenseKeyExt" | grep ".....*-....*-....*-....*-.....*-.....*-...." >/dev/null 2>&1 \
&& LicenseValid="yes" \
|| LicenseValid="no"
if [ "$LicenseValid" != "yes" ]; then
echo
echo "Invalid license key. Please check the license key."
exit 1
fi
ProductCode=`echo $LicenseKeyExt | cut -f 1 -d - | cut -b 1`
PlatformCode=`echo $LicenseKeyExt | cut -f 2 -d - | cut -b 1`
LicenseTypeCode=`echo $LicenseKeyExt | cut -f 3 -d -`
LicenseFeatureCode=`echo $LicenseKeyExt | cut -f 4 -d - | cut -b 1`
# determine which edition we are licensed to use
case "$LicenseTypeCode" in
F4M)
LicenseType="Commercial"
case $ProductCode in
F)
Edition="Universal"
QT_EDITION="QT_EDITION_UNIVERSAL"
;;
B)
Edition="FullFramework"
EditionString="Full Framework"
QT_EDITION="QT_EDITION_DESKTOP"
;;
L)
Edition="GUIFramework"
EditionString="GUI Framework"
QT_EDITION="QT_EDITION_DESKTOPLIGHT"
;;
esac
;;
Z4M|R4M|Q4M)
LicenseType="Evaluation"
QMakeVar add DEFINES QT_EVAL
case $ProductCode in
B)
Edition="Evaluation"
QT_EDITION="QT_EDITION_EVALUATION"
;;
esac
;;
esac
if [ -z "$LicenseType" -o -z "$Edition" -o -z "$QT_EDITION" ]; then
echo
echo "Invalid license key. Please check the license key."
exit 1
fi
# verify that we are licensed to use Qt on this platform
LICENSE_EXTENSION=
if [ "$PlatformCode" = "X" ]; then
# Qt All-OS
LICENSE_EXTENSION="-ALLOS"
elif [ "$PLATFORM_QWS" = "yes" ]; then
case $PlatformCode in
2|4|8|A|B|E|G|J|K|P|Q|S|U|V|W)
# Qt for Embedded Linux
LICENSE_EXTENSION="-EMBEDDED"
;;
*)
echo
echo "You are not licensed for Qt for Embedded Linux."
echo
echo "Please contact qt-info@nokia.com to upgrade your license"
echo "to include Qt for Embedded Linux, or install the"
echo "Qt Open Source Edition if you intend to develop free software."
exit 1
;;
esac
elif [ "$PLATFORM_MAC" = "yes" ]; then
case $PlatformCode in
2|4|5|7|9|B|C|E|F|G|L|M|U|W|Y)
# Qt/Mac
LICENSE_EXTENSION="-DESKTOP"
;;
3|6|8|A|D|H|J|K|P|Q|S|V)
# Embedded no-deploy
LICENSE_EXTENSION="-EMBEDDED"
;;
*)
echo
echo "You are not licensed for the Qt/Mac platform."
echo
echo "Please contact qt-info@nokia.com to upgrade your license"
echo "to include the Qt/Mac platform."
exit 1
;;
esac
else
case $PlatformCode in
2|3|4|5|7|D|E|F|J|M|Q|S|T|V|Z)
# Qt/X11
LICENSE_EXTENSION="-DESKTOP"
;;
6|8|9|A|B|C|G|H|K|P|U|W)
# Embedded no-deploy
LICENSE_EXTENSION="-EMBEDDED"
;;
*)
echo
echo "You are not licensed for the Qt/X11 platform."
echo
echo "Please contact qt-info@nokia.com to upgrade your license to"
echo "include the Qt/X11 platform, or install the Qt Open Source Edition"
echo "if you intend to develop free software."
exit 1
;;
esac
fi
if test -r "$relpath/.LICENSE"; then
# Generic, non-final license
LICENSE_EXTENSION=""
line=`sed 'y/a-z/A-Z/;q' "$relpath"/.LICENSE`
case "$line" in
*BETA*)
Edition=Beta
;;
*TECHNOLOGY?PREVIEW*)
Edition=Preview
;;
*EVALUATION*)
Edition=Evaluation
;;
*)
echo >&2 "Invalid license files; cannot continue"
exit 1
;;
esac
Licensee="$Edition"
EditionString="$Edition"
QT_EDITION="QT_EDITION_DESKTOP"
fi
case "$LicenseFeatureCode" in
G|L)
# US
case "$LicenseType" in
Commercial)
cp -f "$relpath/.LICENSE${LICENSE_EXTENSION}-US" "$outpath/LICENSE"
;;
Evaluation)
cp -f "$relpath/.LICENSE-EVALUATION-US" "$outpath/LICENSE"
;;
esac
;;
2|5)
# non-US
case "$LicenseType" in
Commercial)
cp -f "$relpath/.LICENSE${LICENSE_EXTENSION}" "$outpath/LICENSE"
;;
Evaluation)
cp -f "$relpath/.LICENSE-EVALUATION" "$outpath/LICENSE"
;;
esac
;;
*)
echo
echo "Invalid license key. Please check the license key."
exit 1
;;
esac
if [ '!' -f "$outpath/LICENSE" ]; then
echo "The LICENSE, LICENSE.GPL3 LICENSE.LGPL file shipped with"
echo "this software has disappeared."
echo
echo "Sorry, you are not licensed to use this software."
echo "Try re-installing."
echo
exit 1
fi
elif [ $COMMERCIAL_USER = "no" ]; then
# Open Source edition - may only be used under the terms of the GPL or LGPL.
[ "$PLATFORM_MAC" = "maybe" ] && PLATFORM_MAC=yes
Licensee="Open Source"
Edition="OpenSource"
EditionString="Open Source"
QT_EDITION="QT_EDITION_OPENSOURCE"
fi
#-------------------------------------------------------------------------------
# initalize variables
#-------------------------------------------------------------------------------
SYSTEM_VARIABLES="CC CXX CFLAGS CXXFLAGS LDFLAGS"
for varname in $SYSTEM_VARIABLES; do
qmakevarname="${varname}"
# use LDFLAGS for autoconf compat, but qmake uses QMAKE_LFLAGS
if [ "${varname}" = "LDFLAGS" ]; then
qmakevarname="LFLAGS"
fi
cmd=`echo \
'if [ -n "\$'${varname}'" ]; then
QMakeVar set QMAKE_'${qmakevarname}' "\$'${varname}'"
fi'`
eval "$cmd"
done
# Use CC/CXX to run config.tests
mkdir -p "$outpath/config.tests"
rm -f "$outpath/config.tests/.qmake.cache"
cp "$QMAKE_VARS_FILE" "$outpath/config.tests/.qmake.cache"
QMakeVar add styles "windows"
QMakeVar add imageformat-plugins "gif tiff jpeg"
QMakeVar add mouse-drivers "pc"
if [ "$UNAME_SYSTEM" = "Linux" ] ; then
QMakeVar add gfx-drivers "linuxfb"
QMakeVar add mouse-drivers "linuxtp"
fi
QMakeVar add kbd-drivers "tty"
if [ "$CFG_DEV" = "yes" ]; then
QMakeVar add kbd-drivers "um"
fi
# QTDIR may be set and point to an old or system-wide Qt installation
unset QTDIR
# the minimum version of libdbus-1 that we require:
MIN_DBUS_1_VERSION=0.93
# initalize internal variables
CFG_CONFIGURE_EXIT_ON_ERROR=yes
CFG_PROFILE=no
CFG_EXCEPTIONS=unspecified
CFG_SCRIPT=auto # (yes|no|auto)
CFG_SCRIPTTOOLS=auto # (yes|no|auto)
CFG_XMLPATTERNS=yes
CFG_INCREMENTAL=auto
CFG_QCONFIG=full
# For Symbian bulding on Linux this option is always by default
CFG_DEBUG=yes
CFG_MYSQL_CONFIG=
CFG_DEBUG_RELEASE=auto
CFG_SHARED=yes
CFG_SM=auto
CFG_XSHAPE=auto
CFG_XSYNC=auto
CFG_XINERAMA=runtime
CFG_XFIXES=runtime
CFG_ZLIB=auto
CFG_SQLITE=qt
CFG_GIF=auto
CFG_TIFF=auto
CFG_LIBTIFF=auto
CFG_PNG=yes
CFG_LIBPNG=auto
CFG_JPEG=auto
CFG_LIBJPEG=auto
CFG_MNG=auto
CFG_LIBMNG=auto
CFG_XCURSOR=runtime
CFG_XRANDR=runtime
CFG_XRENDER=auto
CFG_MITSHM=auto
CFG_OPENGL=no
CFG_OPENVG=yes
CFG_OPENVG_LC_INCLUDES=no
CFG_OPENVG_SHIVA=no
CFG_OPENVG_ON_OPENGL=no
CFG_EGL=no
CFG_EGL_GLES_INCLUDES=no
CFG_SSE=auto
CFG_FONTCONFIG=auto
CFG_QWS_FREETYPE=no
CFG_LIBFREETYPE=no
CFG_SQL_AVAILABLE=
QT_DEFAULT_BUILD_PARTS="libs tools examples demos docs translations"
#QTP change for lRelease app. Need for Symbian
CFG_BUILD_PARTS="translations"
CFG_NOBUILD_PARTS=""
CFG_RELEASE_QMAKE=no
CFG_PHONON=yes
CFG_PHONON_BACKEND=yes
CFG_MULTIMEDIA=yes
CFG_SVG=yes
CFG_DECLARATIVE=auto
CFG_WEBKIT=auto # (yes|no|auto)
CFG_JAVASCRIPTCORE_JIT=auto
CFG_GFX_AVAILABLE="linuxfb transformed qvfb vnc multiscreen directfb"
CFG_GFX_ON="linuxfb multiscreen"
CFG_GFX_PLUGIN_AVAILABLE=
CFG_GFX_PLUGIN=
CFG_GFX_OFF=
CFG_KBD_AVAILABLE="tty linuxinput qvfb"
CFG_KBD_ON="tty" #default, see QMakeVar above
CFG_MOUSE_AVAILABLE="pc linuxtp linuxinput tslib qvfb"
CFG_MOUSE_ON="pc linuxtp" #default, see QMakeVar above
if [ -f "$relpath/src/gui/embedded/qscreenqnx_qws.cpp" ]; then
CFG_KBD_AVAILABLE="${CFG_KBD_AVAILABLE} qnx"
CFG_MOUSE_AVAILABLE="${CFG_MOUSE_AVAILABLE} qnx"
CFG_GFX_AVAILABLE="${CFG_GFX_AVAILABLE} qnx"
fi
CFG_ARCH=
CFG_HOST_ARCH=
CFG_KBD_PLUGIN_AVAILABLE=
CFG_KBD_PLUGIN=
CFG_KBD_OFF=
CFG_MOUSE_PLUGIN_AVAILABLE=
CFG_MOUSE_PLUGIN=
CFG_MOUSE_OFF=
CFG_USE_GNUMAKE=no
CFG_IM=yes
CFG_DECORATION_AVAILABLE="styled windows default"
CFG_DECORATION_ON="${CFG_DECORATION_AVAILABLE}" # all on by default
CFG_DECORATION_PLUGIN_AVAILABLE=
CFG_DECORATION_PLUGIN=
CFG_XINPUT=runtime
CFG_XKB=auto
CFG_NIS=auto
CFG_CUPS=auto
CFG_ICONV=no
CFG_DBUS=auto
CFG_GLIB=no
CFG_GSTREAMER=auto
CFG_QGTKSTYLE=auto
CFG_LARGEFILE=auto
CFG_OPENSSL=yes
CFG_PTMALLOC=no
#For Symbian it should be enabled by default
CFG_STL=yes
CFG_S60=yes
CFG_RTTI=yes
CFG_NATIVE_GESTURES=yes
CFG_DEFFILES=yes
#end symbian flags
CFG_PRECOMPILE=auto
CFG_SEPARATE_DEBUG_INFO=auto
CFG_REDUCE_EXPORTS=no
CFG_MMX=auto
CFG_3DNOW=auto
CFG_SSE=auto
CFG_SSE2=auto
CFG_REDUCE_RELOCATIONS=no
CFG_IPV6=yes
CFG_NAS=no
CFG_QWS_DEPTHS=all
CFG_USER_BUILD_KEY=
CFG_ACCESSIBILITY=no
CFG_QT3SUPPORT=no
CFG_ENDIAN=auto
CFG_HOST_ENDIAN=auto
CFG_DOUBLEFORMAT=auto
CFG_ARMFPA=auto
CFG_IWMMXT=no
CFG_CLOCK_GETTIME=auto
CFG_CLOCK_MONOTONIC=auto
CFG_MREMAP=auto
CFG_GETADDRINFO=auto
CFG_IPV6IFNAME=auto
CFG_GETIFADDRS=auto
CFG_INOTIFY=auto
CFG_RPATH=yes
CFG_FRAMEWORK=auto
CFG_MAC_ARCHS=
MAC_CONFIG_TEST_COMMANDLINE= # used to make the configure tests run with the correct arch's and SDK settings
CFG_MAC_DWARF2=auto
CFG_MAC_XARCH=auto
CFG_MAC_CARBON=yes
CFG_MAC_COCOA=auto
COMMANDLINE_MAC_COCOA=no
CFG_SXE=auto
CFG_PREFIX_INSTALL=yes
CFG_SDK=
D_FLAGS=
I_FLAGS=
L_FLAGS=
RPATH_FLAGS=
l_FLAGS=
QCONFIG_FLAGS=
XPLATFORM= # This seems to be the QMAKESPEC, like "linux-g++"
PLATFORM=$QMAKESPEC
QT_CROSS_COMPILE=no
OPT_CONFIRM_LICENSE=no
OPT_SHADOW=maybe
OPT_FAST=auto
OPT_VERBOSE=no
OPT_HELP=
CFG_SILENT=no
CFG_GRAPHICS_SYSTEM=default
CFG_ALSA=auto
#flags for qmake running
CFG_NOPROCESS=no
# initalize variables used for installation
QT_INSTALL_PREFIX="$outpath"
QT_INSTALL_DOCS=
QT_INSTALL_HEADERS=
QT_INSTALL_LIBS=
QT_INSTALL_BINS=
QT_INSTALL_PLUGINS=
QT_INSTALL_DATA=
QT_INSTALL_TRANSLATIONS=
QT_INSTALL_SETTINGS=
QT_INSTALL_EXAMPLES=
QT_INSTALL_DEMOS=
QT_HOST_PREFIX=
#flags for SQL drivers
QT_CFLAGS_PSQL=
QT_LFLAGS_PSQL=
QT_CFLAGS_MYSQL=
QT_LFLAGS_MYSQL=
QT_LFLAGS_MYSQL_R=
QT_CFLAGS_SQLITE=
#for the Symbian sqlite3 is defaultflag
QT_LFLAGS_SQLITE="-lsqlite3"
QT_LFLAGS_ODBC=
# flags for libdbus-1
QT_CFLAGS_DBUS=
QT_LIBS_DBUS=
# QTP:QTPROD-7 Cross compiling on Linux broken
# flags for Symbian style
QT_SYMBIAN_STYLE_FLAGS=
# flags for Glib (X11 only)
QT_CFLAGS_GLIB=
QT_LIBS_GLIB=
# flags for GStreamer (X11 only)
QT_CFLAGS_GSTREAMER=
QT_LIBS_GSTREAMER=
#-------------------------------------------------------------------------------
# check SQL drivers, mouse drivers and decorations available in this package
#-------------------------------------------------------------------------------
# opensource version removes some drivers, so force them to be off
CFG_SQL_tds=no
CFG_SQL_oci=no
CFG_SQL_db2=no
CFG_SQL_AVAILABLE=
if [ -d "$relpath/src/plugins/sqldrivers" ]; then
for a in "$relpath/src/plugins/sqldrivers/"*; do
if [ -d "$a" ]; then
base_a=`basename "$a"`
CFG_SQL_AVAILABLE="${CFG_SQL_AVAILABLE} ${base_a}"
eval "CFG_SQL_${base_a}=auto"
fi
done
fi
CFG_DECORATION_PLUGIN_AVAILABLE=
if [ -d "$relpath/src/plugins/decorations" ]; then
for a in "$relpath/src/plugins/decorations/"*; do
if [ -d "$a" ]; then
base_a=`basename "$a"`
CFG_DECORATION_PLUGIN_AVAILABLE="${CFG_DECORATION_PLUGIN_AVAILABLE} ${base_a}"
fi
done
fi
CFG_KBD_PLUGIN_AVAILABLE=
if [ -d "$relpath/src/plugins/kbddrivers" ]; then
for a in "$relpath/src/plugins/kbddrivers/"*; do
if [ -d "$a" ]; then
base_a=`basename "$a"`
CFG_KBD_PLUGIN_AVAILABLE="${CFG_KBD_PLUGIN_AVAILABLE} ${base_a}"
fi
done
fi
CFG_MOUSE_PLUGIN_AVAILABLE=
if [ -d "$relpath/src/plugins/mousedrivers" ]; then
for a in "$relpath/src/plugins/mousedrivers/"*; do
if [ -d "$a" ]; then
base_a=`basename "$a"`
CFG_MOUSE_PLUGIN_AVAILABLE="${CFG_MOUSE_PLUGIN_AVAILABLE} ${base_a}"
fi
done
fi
CFG_GFX_PLUGIN_AVAILABLE=
if [ -d "$relpath/src/plugins/gfxdrivers" ]; then
for a in "$relpath/src/plugins/gfxdrivers/"*; do
if [ -d "$a" ]; then
base_a=`basename "$a"`
CFG_GFX_PLUGIN_AVAILABLE="${CFG_GFX_PLUGIN_AVAILABLE} ${base_a}"
fi
done
CFG_GFX_OFF="$CFG_GFX_AVAILABLE" # assume all off
fi
#-------------------------------------------------------------------------------
# parse command line arguments
#-------------------------------------------------------------------------------
# parse the arguments, setting things to "yes" or "no"
while [ "$#" -gt 0 ]; do
CURRENT_OPT="$1"
UNKNOWN_ARG=no
case "$1" in
#Autoconf style options
--enable-*)
VAR=`echo $1 | sed "s,^--enable-\(.*\),\1,"`
VAL=yes
;;
--disable-*)
VAR=`echo $1 | sed "s,^--disable-\(.*\),\1,"`
VAL=no
;;
--*=*)
VAR=`echo $1 | sed "s,^--\(.*\)=.*,\1,"`
VAL=`echo $1 | sed "s,^--.*=\(.*\),\1,"`
;;
--no-*)
VAR=`echo $1 | sed "s,^--no-\(.*\),\1,"`
VAL=no
;;
--*)
VAR=`echo $1 | sed "s,^--\(.*\),\1,"`
VAL=yes
;;
#QTP:QTPPROD-7
#Qt Symbian style options
-*-style-s60)
VAR=`echo $1 | sed "s,^-[^-]*-\(.*\),\1,"`
if [ "$1" = "-no-style-s60" ]; then
VAL=no
else
VAL=yes
fi
;;
#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 yes options
-incremental|-qvfb|-profile|-shared|-static|-sm|-xinerama|-xshape|-xsync|-xinput|-reduce-exports|-pch|-separate-debug-info|-stl|-freetype|-xcursor|-xfixes|-xrandr|-xrender|-mitshm|-fontconfig|-xkb|-nis|-qdbus|-dbus|-dbus-linked|-glib|-gstreamer|-gtkstyle|-cups|-iconv|-largefile|-h|-help|-v|-verbose|-debug|-release|-fast|-accessibility|-confirm-license|-gnumake|-framework|-qt3support|-debug-and-release|-exceptions|-cocoa|-universal|-prefix-install|-silent|-armfpa|-optimized-qmake|-dwarf2|-reduce-relocations|-sse|-openssl|-openssl-linked|-ptmalloc|-xmlpatterns|-phonon|-phonon-backend|-multimedia|-svg|-declarative|-webkit|-javascript-jit|-script|-scripttools|-rpath|-force-pkg-config)
VAR=`echo $1 | sed "s,^-\(.*\),\1,"`
VAL=yes
;;
#Qt style options that pass an argument
-qconfig)
if [ "$PLATFORM_QWS" != "yes" ]; then
echo
echo "WARNING: -qconfig is only tested and supported on Qt for Embedded Linux."
echo
fi
CFG_QCONFIG="$VAL"
VAR=`echo $1 | sed "s,^-\(.*\),\1,"`
shift
VAL=$1
;;
-prefix|-docdir|-headerdir|-plugindir|-datadir|-libdir|-bindir|-translationdir|-sysconfdir|-examplesdir|-demosdir|-depths|-make|-nomake|-platform|-xplatform|-buildkey|-sdk|-arch|-host-arch|-mysql_config)
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
-k|-continue)
VAR=fatal_error
VAL=no
;;
-embedded)
VAR=embedded
# this option may or may not be followed by an argument
if [ -z "$2" ] || echo "$2" | grep '^-' >/dev/null 2>&1; then
VAL=auto
else
shift;
VAL=$1
fi
;;
-opengl)
VAR=opengl
# this option may or may not be followed by an argument
if [ -z "$2" ] || echo "$2" | grep '^-' >/dev/null 2>&1; then
VAL=yes
else
shift;
VAL=$1
fi
;;
-openvg)
VAR=openvg
# this option may or may not be followed by an argument
if [ -z "$2" ] || echo "$2" | grep '^-' >/dev/null 2>&1; then
VAL=yes
else
shift;
VAL=$1
fi
;;
-usedeffiles)
VAR=`echo $1 | sed "s,^-\(.*\),\1,"`
VAL=yes
;;
-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
;;
-host-*-endian)
VAR=host_endian
VAL=`echo $1 | sed "s,^-.*-\(.*\)-.*,\1,"`
;;
-*-endian)
VAR=endian
VAL=`echo $1 | sed "s,^-\(.*\)-.*,\1,"`
;;
-qtnamespace)
VAR="qtnamespace"
shift
VAL="$1"
;;
-graphicssystem)
VAR="graphicssystem"
shift
VAL=$1
;;
-qtlibinfix)
VAR="qtlibinfix"
shift
VAL="$1"
;;
-D?*|-D)
VAR="add_define"
if [ "$1" = "-D" ]; then
shift
VAL="$1"
else
VAL=`echo $1 | sed 's,-D,,'`
fi
;;
-I?*|-I)
VAR="add_ipath"
if [ "$1" = "-I" ]; then
shift
VAL="$1"
else
VAL=`echo $1 | sed 's,-I,,'`
fi
;;
-L?*|-L)
VAR="add_lpath"
if [ "$1" = "-L" ]; then
shift
VAL="$1"
else
VAL=`echo $1 | sed 's,-L,,'`
fi
;;
-R?*|-R)
VAR="add_rpath"
if [ "$1" = "-R" ]; then
shift
VAL="$1"
else
VAL=`echo $1 | sed 's,-R,,'`
fi
;;
-l?*)
VAR="add_link"
VAL=`echo $1 | sed 's,-l,,'`
;;
-F?*|-F)
VAR="add_fpath"
if [ "$1" = "-F" ]; then
shift
VAL="$1"
else
VAL=`echo $1 | sed 's,-F,,'`
fi
;;
-fw?*|-fw)
VAR="add_framework"
if [ "$1" = "-fw" ]; then
shift
VAL="$1"
else
VAL=`echo $1 | sed 's,-fw,,'`
fi
;;
-*)
VAR=`echo $1 | sed "s,^-\(.*\),\1,"`
VAL="unknown"
;;
*)
UNKNOWN_ARG=yes
;;
esac
if [ "$UNKNOWN_ARG" = "yes" ]; then
echo "$1: unknown argument"
OPT_HELP=yes
ERROR=yes
shift
continue
fi
shift
UNKNOWN_OPT=no
case "$VAR" in
qt3support)
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
CFG_QT3SUPPORT="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
accessibility)
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
CFG_ACCESSIBILITY="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
license)
LICENSE_FILE="$VAL"
;;
gnumake)
CFG_USE_GNUMAKE="$VAL"
;;
mysql_config)
CFG_MYSQL_CONFIG="$VAL"
;;
prefix)
QT_INSTALL_PREFIX="$VAL"
;;
hostprefix)
QT_HOST_PREFIX="$VAL"
;;
force-pkg-config)
QT_FORCE_PKGCONFIG=yes
;;
docdir)
QT_INSTALL_DOCS="$VAL"
;;
headerdir)
QT_INSTALL_HEADERS="$VAL"
;;
plugindir)
QT_INSTALL_PLUGINS="$VAL"
;;
datadir)
QT_INSTALL_DATA="$VAL"
;;
libdir)
QT_INSTALL_LIBS="$VAL"
;;
qtnamespace)
QT_NAMESPACE="$VAL"
;;
qtlibinfix)
QT_LIBINFIX="$VAL"
;;
translationdir)
QT_INSTALL_TRANSLATIONS="$VAL"
;;
sysconfdir|settingsdir)
QT_INSTALL_SETTINGS="$VAL"
;;
examplesdir)
QT_INSTALL_EXAMPLES="$VAL"
;;
demosdir)
QT_INSTALL_DEMOS="$VAL"
;;
qconfig)
CFG_QCONFIG="$VAL"
;;
bindir)
QT_INSTALL_BINS="$VAL"
;;
buildkey)
CFG_USER_BUILD_KEY="$VAL"
;;
sxe)
CFG_SXE="$VAL"
;;
embedded)
CFG_EMBEDDED="$VAL"
if [ "$PLATFORM_QWS" != "no" ]; then
if [ "$PLATFORM_QWS" = "maybe" ]; then
PLATFORM_X11=no
PLATFORM_MAC=no
PLATFORM_QWS=yes
fi
else
echo "No license exists to enable Qt for Embedded Linux. Disabling."
CFG_EMBEDDED=no
fi
;;
sse)
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
CFG_SSE="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
endian)
if [ "$VAL" = "little" ]; then
CFG_ENDIAN="Q_LITTLE_ENDIAN"
elif [ "$VAL" = "big" ]; then
CFG_ENDIAN="Q_BIG_ENDIAN"
else
UNKNOWN_OPT=yes
fi
;;
host_endian)
if [ "$VAL" = "little" ]; then
CFG_HOST_ENDIAN="Q_LITTLE_ENDIAN"
elif [ "$VAL" = "big" ]; then
CFG_HOST_ENDIAN="Q_BIG_ENDIAN"
else
UNKNOWN_OPT=yes
fi
;;
#QTP: QTPPROD-7
usedeffiles)
CFG_DEFFILES="$VAL"
;;
style-s60)
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
QT_SYMBIAN_STYLE_FLAGS="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
armfpa)
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
CFG_ARMFPA="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
depths)
CFG_QWS_DEPTHS="$VAL"
;;
*-s60)
CFG_S60="$VAL"
;;
opengl)
if [ "$VAL" = "auto" ] || [ "$VAL" = "desktop" ] ||
[ "$VAL" = "yes" ] || [ "$VAL" = "no" ] ||
[ "$VAL" = "es1cl" ] || [ "$VAL" = "es1" ] || [ "$VAL" = "es2" ]; then
CFG_OPENGL="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
openvg)
if [ "$VAL" = "auto" ] || [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
CFG_OPENVG="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
graphicssystem)
if [ "$PLATFORM_QWS" = "yes" ]; then
echo "Error: Graphics System plugins are not supported on QWS."
echo " On QWS, the graphics system API is part of the QScreen plugin architecture "
echo " rather than existing as a separate plugin."
echo ""
UNKNOWN_OPT=yes
else
if [ "$VAL" = "opengl" ]; then
CFG_GRAPHICS_SYSTEM="opengl"
elif [ "$VAL" = "openvg" ]; then
CFG_GRAPHICS_SYSTEM="openvg"
elif [ "$VAL" = "raster" ]; then
CFG_GRAPHICS_SYSTEM="raster"
else
UNKNOWN_OPT=yes
fi
fi
;;
qvfb) # left for commandline compatibility, not documented
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
if [ "$VAL" = "yes" ]; then
QMakeVar add gfx-drivers qvfb
QMakeVar add kbd-drivers qvfb
QMakeVar add mouse-drivers qvfb
CFG_GFX_ON="$CFG_GFX_ON qvfb"
CFG_KBD_ON="$CFG_KBD_ON qvfb"
CFG_MOUSE_ON="$CFG_MOUSE_ON qvfb"
fi
else
UNKNOWN_OPT=yes
fi
;;
nomake)
CFG_NOBUILD_PARTS="$CFG_NOBUILD_PARTS $VAL"
;;
make)
CFG_BUILD_PARTS="$CFG_BUILD_PARTS $VAL"
;;
x11)
if [ "$PLATFORM_MAC" = "yes" ]; then
PLATFORM_MAC=no
elif [ "$PLATFORM_QWS" = "yes" ]; then
PLATFORM_QWS=no
fi
if [ "$CFG_FRAMEWORK" = "auto" ]; then
CFG_FRAMEWORK=no
fi
PLATFORM_X11=yes
;;
sdk)
if [ "$PLATFORM_MAC" = "yes" ]; then
CFG_SDK="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
dwarf2)
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
CFG_MAC_DWARF2="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
arch)
if [ "$PLATFORM_MAC" = "yes" ]; then
CFG_MAC_ARCHS="$CFG_MAC_ARCHS $VAL"
else
CFG_ARCH=$VAL
fi
;;
host-arch)
CFG_HOST_ARCH=$VAL
;;
universal)
if [ "$PLATFORM_MAC" = "yes" ] && [ "$VAL" = "yes" ]; then
CFG_MAC_ARCHS="$CFG_MAC_ARCHS x86 ppc"
else
UNKNOWN_OPT=yes
fi
;;
cocoa)
if [ "$PLATFORM_MAC" = "yes" ] && [ "$VAL" = "yes" ]; then
CFG_MAC_COCOA="$VAL"
COMMANDLINE_MAC_COCOA="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
framework)
if [ "$PLATFORM_MAC" = "yes" ]; then
CFG_FRAMEWORK="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
profile)
if [ "$VAL" = "yes" ]; then
CFG_PROFILE=yes
QMakeVar add QMAKE_CFLAGS -pg
QMakeVar add QMAKE_CXXFLAGS -pg
QMakeVar add QMAKE_LFLAGS -pg
QMAKE_VARS="$QMAKE_VARS CONFIG+=nostrip"
else
UNKNOWN_OPT=yes
fi
;;
exceptions|g++-exceptions)
if [ "$VAL" = "no" ]; then
CFG_EXCEPTIONS=no
elif [ "$VAL" = "yes" ]; then
CFG_EXCEPTIONS=yes
else
UNKNOWN_OPT=yes
fi
;;
platform)
PLATFORM="$VAL"
# keep compatibility with old platform names
case $PLATFORM in
aix-64)
PLATFORM=aix-xlc-64
;;
hpux-o64)
PLATFORM=hpux-acc-o64
;;
hpux-n64)
PLATFORM=hpux-acc-64
;;
hpux-acc-n64)
PLATFORM=hpux-acc-64
;;
irix-n32)
PLATFORM=irix-cc
;;
irix-64)
PLATFORM=irix-cc-64
;;
irix-cc-n64)
PLATFORM=irix-cc-64
;;
reliant-64)
PLATFORM=reliant-cds-64
;;
solaris-64)
PLATFORM=solaris-cc-64
;;
solaris-64)
PLATFORM=solaris-cc-64
;;
openunix-cc)
PLATFORM=unixware-cc
;;
openunix-g++)
PLATFORM=unixware-g++
;;
unixware7-cc)
PLATFORM=unixware-cc
;;
unixware7-g++)
PLATFORM=unixware-g++
;;
macx-g++-64)
PLATFORM=macx-g++
NATIVE_64_ARCH=
case `uname -p` in
i386) NATIVE_64_ARCH="x86_64" ;;
powerpc) NATIVE_64_ARCH="ppc64" ;;
*) echo "WARNING: Can't detect CPU architecture for macx-g++-64" ;;
esac
if [ ! -z "$NATIVE_64_ARCH" ]; then
QTCONFIG_CONFIG="$QTCONFIG_CONFIG $NATIVE_64_ARCH"
CFG_MAC_ARCHS="$CFG_MAC_ARCHS $NATIVE_64_ARCH"
fi
;;
esac
;;
xplatform)
XPLATFORM="$VAL"
# QTP:QTPROD-7 Cross compiling on Linux broken
if [ "$CFG_ENDIAN" = "auto" ] && [ "$XPLATFORM"="symbian-sbsv2" ]; then
CFG_ENDIAN="Q_LITTLE_ENDIAN"
fi
;;
debug-and-release)
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
CFG_DEBUG_RELEASE="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
optimized-qmake)
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
CFG_RELEASE_QMAKE="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
release)
if [ "$VAL" = "yes" ]; then
CFG_DEBUG=no
elif [ "$VAL" = "no" ]; then
CFG_DEBUG=yes
else
UNKNOWN_OPT=yes
fi
;;
prefix-install)
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
CFG_PREFIX_INSTALL="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
debug)
CFG_DEBUG="$VAL"
;;
developer-build|commercial|opensource|nokia-developer)
# These switches have been dealt with already
CFG_DEFFILES=no
;;
static)
if [ "$VAL" = "yes" ]; then
CFG_SHARED=no
elif [ "$VAL" = "no" ]; then
CFG_SHARED=yes
else
UNKNOWN_OPT=yes
fi
;;
incremental)
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
CFG_INCREMENTAL="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
fatal_error)
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
CFG_CONFIGURE_EXIT_ON_ERROR="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
feature-*)
if [ "$PLATFORM_QWS" = "yes" ]; then
FEATURE=`echo $VAR | sed "s,^[^-]*-\([^-]*\),\1," | tr 'abcdefghijklmnopqrstuvwxyz-' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ_'`
if [ "$VAL" = "no" ]; then
QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_$FEATURE"
elif [ "$VAL" = "yes" ] || [ "$VAL" = "unknown" ]; then
QCONFIG_FLAGS="$QCONFIG_FLAGS QT_$FEATURE"
else
UNKNOWN_OPT=yes
fi
else
UNKNOWN_OPT=yes
fi
;;
shared)
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
CFG_SHARED="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
gif)
[ "$VAL" = "qt" ] && VAL=yes
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
CFG_GIF="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
sm)
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
CFG_SM="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
xinerama)
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ] || [ "$VAL" = "runtime" ]; then
CFG_XINERAMA="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
xshape)
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
CFG_XSHAPE="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
xsync)
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
CFG_XSYNC="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
xinput)
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ] || [ "$VAL" = "runtime" ]; then
CFG_XINPUT="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
stl)
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
CFG_STL="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
pch)
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
CFG_PRECOMPILE="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
separate-debug-info)
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
CFG_SEPARATE_DEBUG_INFO="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
reduce-exports)
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
CFG_REDUCE_EXPORTS="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
mmx)
if [ "$VAL" = "no" ]; then
CFG_MMX="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
3dnow)
if [ "$VAL" = "no" ]; then
CFG_3DNOW="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
sse)
if [ "$VAL" = "no" ]; then
CFG_SSE="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
sse2)
if [ "$VAL" = "no" ]; then
CFG_SSE2="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
iwmmxt)
CFG_IWMMXT="yes"
;;
reduce-relocations)
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
CFG_REDUCE_RELOCATIONS="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
freetype)
[ "$VAL" = "qt" ] && VAL=yes
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ] || [ "$VAL" = "system" ]; then
CFG_QWS_FREETYPE="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
zlib)
[ "$VAL" = "qt" ] && VAL=yes
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ] || [ "$VAL" = "system" ]; then
CFG_ZLIB="$VAL"
else
UNKNOWN_OPT=yes
fi
# No longer supported:
#[ "$VAL" = "no" ] && CFG_LIBPNG=no
;;
sqlite)
if [ "$VAL" = "system" ]; then
CFG_SQLITE=system
else
UNKNOWN_OPT=yes
fi
;;
libpng)
[ "$VAL" = "yes" ] && VAL=qt
if [ "$VAL" = "qt" ] || [ "$VAL" = "no" ] || [ "$VAL" = "system" ]; then
CFG_LIBPNG="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
libjpeg)
[ "$VAL" = "yes" ] && VAL=qt
if [ "$VAL" = "qt" ] || [ "$VAL" = "no" ] || [ "$VAL" = "system" ]; then
CFG_LIBJPEG="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
libmng)
[ "$VAL" = "yes" ] && VAL=qt
if [ "$VAL" = "qt" ] || [ "$VAL" = "no" ] || [ "$VAL" = "system" ]; then
CFG_LIBMNG="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
libtiff)
[ "$VAL" = "yes" ] && VAL=qt
if [ "$VAL" = "qt" ] || [ "$VAL" = "no" ] || [ "$VAL" = "system" ]; then
CFG_LIBTIFF="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
nas-sound)
if [ "$VAL" = "system" ] || [ "$VAL" = "no" ]; then
CFG_NAS="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
xcursor)
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ] || [ "$VAL" = "runtime" ]; then
CFG_XCURSOR="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
xfixes)
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ] || [ "$VAL" = "runtime" ]; then
CFG_XFIXES="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
xrandr)
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ] || [ "$VAL" = "runtime" ]; then
CFG_XRANDR="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
xrender)
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
CFG_XRENDER="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
mitshm)
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
CFG_MITSHM="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
fontconfig)
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
CFG_FONTCONFIG="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
xkb)
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
CFG_XKB="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
cups)
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
CFG_CUPS="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
iconv)
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
CFG_ICONV="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
glib)
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
CFG_GLIB="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
gstreamer)
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
CFG_GSTREAMER="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
gtkstyle)
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
CFG_QGTKSTYLE="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
qdbus|dbus)
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ] || [ "$VAL" = "linked" ]; then
CFG_DBUS="$VAL"
elif [ "$VAL" = "runtime" ]; then
CFG_DBUS="yes"
else
UNKNOWN_OPT=yes
fi
;;
dbus-linked)
if [ "$VAL" = "yes" ]; then
CFG_DBUS="linked"
else
UNKNOWN_OPT=yes
fi
;;
nis)
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
CFG_NIS="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
largefile)
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
CFG_LARGEFILE="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
openssl)
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
CFG_OPENSSL="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
openssl-linked)
if [ "$VAL" = "yes" ]; then
CFG_OPENSSL="linked"
else
UNKNOWN_OPT=yes
fi
;;
ptmalloc)
if [ "$VAL" = "yes" ]; then
CFG_PTMALLOC="yes"
else
UNKNOWN_OPT=yes
fi
;;
xmlpatterns)
if [ "$VAL" = "yes" ] || [ "$VAL" = "auto" ]; then
CFG_XMLPATTERNS="yes"
else
if [ "$VAL" = "no" ]; then
CFG_XMLPATTERNS="no"
else
UNKNOWN_OPT=yes
fi
fi
;;
script)
if [ "$VAL" = "yes" ] || [ "$VAL" = "auto" ]; then
CFG_SCRIPT="yes"
else
if [ "$VAL" = "no" ]; then
CFG_SCRIPT="no"
else
UNKNOWN_OPT=yes
fi
fi
;;
scripttools)
if [ "$VAL" = "yes" ] || [ "$VAL" = "auto" ]; then
CFG_SCRIPTTOOLS="yes"
else
if [ "$VAL" = "no" ]; then
CFG_SCRIPTTOOLS="no"
else
UNKNOWN_OPT=yes
fi
fi
;;
svg)
if [ "$VAL" = "yes" ] || [ "$VAL" = "auto" ]; then
CFG_SVG="yes"
else
if [ "$VAL" = "no" ]; then
CFG_SVG="no"
else
UNKNOWN_OPT=yes
fi
fi
;;
declarative)
if [ "$VAL" = "yes" ]; then
CFG_DECLARATIVE="yes"
else
if [ "$VAL" = "no" ]; then
CFG_DECLARATIVE="no"
else
UNKNOWN_OPT=yes
fi
fi
;;
webkit)
if [ "$VAL" = "yes" ] || [ "$VAL" = "auto" ]; then
CFG_WEBKIT="yes"
else
if [ "$VAL" = "no" ]; then
CFG_WEBKIT="no"
else
UNKNOWN_OPT=yes
fi
fi
;;
javascript-jit)
if [ "$VAL" = "yes" ] || [ "$VAL" = "auto" ] || [ "$VAL" = "no" ]; then
CFG_JAVASCRIPTCORE_JIT="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
confirm-license)
if [ "$VAL" = "yes" ]; then
OPT_CONFIRM_LICENSE="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
h|help)
if [ "$VAL" = "yes" ]; then
OPT_HELP="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
sql-*|gfx-*|decoration-*|kbd-*|mouse-*)
# if Qt style options were used, $VAL can be "no", "qt", or "plugin"
# if autoconf style options were used, $VAL can be "yes" or "no"
[ "$VAL" = "yes" ] && VAL=qt
# now $VAL should be "no", "qt", or "plugin"... double-check
if [ "$VAL" != "no" ] && [ "$VAL" != "qt" ] && [ "$VAL" != "plugin" ]; then
UNKNOWN_OPT=yes
fi
# now $VAL is "no", "qt", or "plugin"
OPT="$VAL"
VAL=`echo $VAR | sed "s,^[^-]*-\([^-]*\).*,\1,"`
VAR=`echo $VAR | sed "s,^\([^-]*\).*,\1,"`
# Grab the available values
case "$VAR" in
sql)
avail="$CFG_SQL_AVAILABLE"
;;
gfx)
avail="$CFG_GFX_AVAILABLE"
if [ "$OPT" = "plugin" ]; then
avail="$CFG_GFX_PLUGIN_AVAILABLE"
fi
;;
decoration)
avail="$CFG_DECORATION_AVAILABLE"
if [ "$OPT" = "plugin" ]; then
avail="$CFG_DECORATION_PLUGIN_AVAILABLE"
fi
;;
kbd)
avail="$CFG_KBD_AVAILABLE"
if [ "$OPT" = "plugin" ]; then
avail="$CFG_KBD_PLUGIN_AVAILABLE"
fi
;;
mouse)
avail="$CFG_MOUSE_AVAILABLE"
if [ "$OPT" = "plugin" ]; then
avail="$CFG_MOUSE_PLUGIN_AVAILABLE"
fi
;;
*)
avail=""
echo "BUG: Unhandled type $VAR used in $CURRENT_OPT"
;;
esac
# Check that that user's value is available.
found=no
for d in $avail; do
if [ "$VAL" = "$d" ]; then
found=yes
break
fi
done
[ "$found" = yes ] || ERROR=yes
if [ "$VAR" = "sql" ]; then
# set the CFG_SQL_driver
eval "CFG_SQL_$VAL=\$OPT"
continue
fi
if [ "$OPT" = "plugin" ] || [ "$OPT" = "qt" ]; then
if [ "$OPT" = "plugin" ]; then
[ "$VAR" = "decoration" ] && QMakeVar del "${VAR}s" "$VAL"
[ "$VAR" = "decoration" ] && CFG_DECORATION_ON=`echo "${CFG_DECORATION_ON} " | sed "s,${VAL} ,,g"` && CFG_DECORATION_PLUGIN="$CFG_DECORATION_PLUGIN ${VAL}"
[ "$VAR" = "kbd" ] && QMakeVar del "${VAR}s" "$VAL"
[ "$VAR" = "kbd" ] && CFG_KBD_ON=`echo "${CFG_MOUSE_ON} " | sed "s,${VAL} ,,g"` && CFG_KBD_PLUGIN="$CFG_KBD_PLUGIN ${VAL}"
[ "$VAR" = "mouse" ] && QMakeVar del "${VAR}s" "$VAL"
[ "$VAR" = "mouse" ] && CFG_MOUSE_ON=`echo "${CFG_MOUSE_ON} " | sed "s,${VAL} ,,g"` && CFG_MOUSE_PLUGIN="$CFG_MOUSE_PLUGIN ${VAL}"
[ "$VAR" = "gfx" ] && QMakeVar del "${VAR}s" "$VAL"
[ "$VAR" = "gfx" ] && CFG_GFX_ON=`echo "${CFG_GFX_ON} " | sed "s,${VAL} ,,g"` && CFG_GFX_PLUGIN="${CFG_GFX_PLUGIN} ${VAL}"
VAR="${VAR}-${OPT}"
else
if [ "$VAR" = "gfx" ] || [ "$VAR" = "kbd" ] || [ "$VAR" = "decoration" ] || [ "$VAR" = "mouse" ]; then
[ "$VAR" = "gfx" ] && CFG_GFX_ON="$CFG_GFX_ON $VAL"
[ "$VAR" = "kbd" ] && CFG_KBD_ON="$CFG_KBD_ON $VAL"
[ "$VAR" = "decoration" ] && CFG_DECORATION_ON="$CFG_DECORATION_ON $VAL"
[ "$VAR" = "mouse" ] && CFG_MOUSE_ON="$CFG_MOUSE_ON $VAL"
VAR="${VAR}-driver"
fi
fi
QMakeVar add "${VAR}s" "${VAL}"
elif [ "$OPT" = "no" ]; then
PLUG_VAR="${VAR}-plugin"
if [ "$VAR" = "gfx" ] || [ "$VAR" = "kbd" ] || [ "$VAR" = "mouse" ]; then
IN_VAR="${VAR}-driver"
else
IN_VAR="${VAR}"
fi
[ "$VAR" = "decoration" ] && CFG_DECORATION_ON=`echo "${CFG_DECORATION_ON} " | sed "s,${VAL} ,,g"`
[ "$VAR" = "gfx" ] && CFG_GFX_ON=`echo "${CFG_GFX_ON} " | sed "s,${VAL} ,,g"`
[ "$VAR" = "kbd" ] && CFG_KBD_ON=`echo "${CFG_KBD_ON} " | sed "s,${VAL} ,,g"`
[ "$VAR" = "mouse" ] && CFG_MOUSE_ON=`echo "${CFG_MOUSE_ON} " | sed "s,${VAL} ,,g"`
QMakeVar del "${IN_VAR}s" "$VAL"
QMakeVar del "${PLUG_VAR}s" "$VAL"
fi
if [ "$ERROR" = "yes" ]; then
echo "$CURRENT_OPT: unknown argument"
OPT_HELP=yes
fi
;;
v|verbose)
if [ "$VAL" = "yes" ]; then
if [ "$OPT_VERBOSE" = "$VAL" ]; then # takes two verboses to turn on qmake debugs
QMAKE_SWITCHES="$QMAKE_SWITCHES -d"
else
OPT_VERBOSE=yes
fi
elif [ "$VAL" = "no" ]; then
if [ "$OPT_VERBOSE" = "$VAL" ] && echo "$QMAKE_SWITCHES" | grep ' -d' >/dev/null 2>&1; then
QMAKE_SWITCHES=`echo $QMAKE_SWITCHES | sed "s, -d,,"`
else
OPT_VERBOSE=no
fi
else
UNKNOWN_OPT=yes
fi
;;
fast)
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
OPT_FAST="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
rpath)
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
CFG_RPATH="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
add_define)
D_FLAGS="$D_FLAGS \"$VAL\""
;;
add_ipath)
I_FLAGS="$I_FLAGS -I\"${VAL}\""
;;
add_lpath)
L_FLAGS="$L_FLAGS -L\"${VAL}\""
;;
add_rpath)
RPATH_FLAGS="$RPATH_FLAGS \"${VAL}\""
;;
add_link)
l_FLAGS="$l_FLAGS -l\"${VAL}\""
;;
add_fpath)
if [ "$PLATFORM_MAC" = "yes" ]; then
L_FLAGS="$L_FLAGS -F\"${VAL}\""
I_FLAGS="$I_FLAGS -F\"${VAL}\""
else
UNKNOWN_OPT=yes
fi
;;
add_framework)
if [ "$PLATFORM_MAC" = "yes" ]; then
l_FLAGS="$l_FLAGS -framework \"${VAL}\""
else
UNKNOWN_OPT=yes
fi
;;
silent)
CFG_SILENT="$VAL"
;;
phonon)
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
CFG_PHONON="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
phonon-backend)
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
CFG_PHONON_BACKEND="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
multimedia)
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
CFG_MULTIMEDIA="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
dont-process)
CFG_NOPROCESS=yes
;;
process)
CFG_NOPROCESS=no
;;
*)
UNKNOWN_OPT=yes
;;
esac
if [ "$UNKNOWN_OPT" = "yes" ]; then
echo "${CURRENT_OPT}: invalid command-line switch"
OPT_HELP=yes
ERROR=yes
fi
done
#QTP Symbian release on the Linux platform
if [ "$XPLATFORM"="symbian-sbsv2" ]; then
PLATFORM_SYMBIAN=yes
fi
if [ "$CFG_QCONFIG" != "full" ] && [ "$CFG_QT3SUPPORT" = "yes" ]; then
echo "Warning: '-qconfig $CFG_QCONFIG' will disable the qt3support library."
CFG_QT3SUPPORT="no"
fi
# update QT_CONFIG to show our current predefined configuration
case "$CFG_QCONFIG" in
minimal|small|medium|large|full)
# these are a sequence of increasing functionality
for c in minimal small medium large full; do
QT_CONFIG="$QT_CONFIG $c-config"
[ "$CFG_QCONFIG" = $c ] && break
done
;;
*)
# not known to be sufficient for anything
if [ '!' -f "$relpath/src/corelib/global/qconfig-${CFG_QCONFIG}.h" ]; then
echo >&2 "Error: configuration file not found:"
echo >&2 " $relpath/src/corelib/global/qconfig-${CFG_QCONFIG}.h"
OPT_HELP=yes
fi
esac
#-------------------------------------------------------------------------------
# build tree initialization
#-------------------------------------------------------------------------------
# where to find which..
unixtests="$relpath/config.tests/unix"
mactests="$relpath/config.tests/mac"
WHICH="$unixtests/which.test"
PERL=`$WHICH perl 2>/dev/null`
# find out which awk we want to use, prefer gawk, then nawk, then regular awk
AWK=
for e in gawk nawk awk; do
if "$WHICH" $e >/dev/null 2>&1 && ( $e -f /dev/null /dev/null ) >/dev/null 2>&1; then
AWK=$e
break
fi
done
# find perl
PERL="/usr/bin/perl"
if "$WHICH" perl >/dev/null 2>&1 && ( perl /dev/null ) >/dev/null 2>&1; then
PERL=`$WHICH perl`
fi
### skip this if the user just needs help...
if [ "$OPT_HELP" != "yes" ]; then
# 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 [ "$PLATFORM_X11" = "yes" -o "$PLATFORM_QWS" = "yes" ] && [ "$CFG_DEBUG_RELEASE" = "yes" ]; then
echo
echo "WARNING: -debug-and-release is not supported anymore on Qt/X11 and Qt for Embedded Linux"
echo "By default, Qt is built in release mode with separate debug information, so"
echo "-debug-and-release is not necessary anymore"
echo
fi
# detect build style
if [ "$CFG_DEBUG" = "auto" ]; then
if [ "$PLATFORM_MAC" = "yes" ]; then
CFG_DEBUG_RELEASE=yes
CFG_DEBUG=yes
elif [ "$CFG_DEV" = "yes" ]; then
CFG_DEBUG_RELEASE=yes
CFG_DEBUG=yes
else
CFG_DEBUG_RELEASE=no
CFG_DEBUG=no
fi
fi
if [ "$CFG_DEBUG_RELEASE" = "yes" ]; then
QMAKE_CONFIG="$QMAKE_CONFIG build_all"
fi
if [ "$CFG_SILENT" = "yes" ]; then
QMAKE_CONFIG="$QMAKE_CONFIG silent"
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..."
if [ -z "$PERL" ]; then
echo
echo "You need perl in your PATH to make a shadow build."
echo "Cannot proceed."
exit 1
fi
[ -d "$outpath/bin" ] || mkdir -p "$outpath/bin"
# symlink the qmake directory
find "$relpath/qmake" | while read a; do
my_a=`echo "$a" | sed "s,^${relpath}/,${outpath}/,"`
if [ '!' -f "$my_a" ]; then
if [ -d "$a" ]; then
# directories are created...
mkdir -p "$my_a"
else
a_dir=`dirname "$my_a"`
[ -d "$a_dir" ] || mkdir -p "$a_dir"
# ... and files are symlinked
case `basename "$a"` in
*.o|*.d|GNUmakefile*|qmake)
;;
*)
rm -f "$my_a"
ln -s "$a" "$my_a"
;;
esac
fi
fi
done
# make a syncqt script that can be used in the shadow
rm -f "$outpath/bin/syncqt"
if [ -x "$relpath/bin/syncqt" ]; then
mkdir -p "$outpath/bin"
echo "#!/bin/sh" >"$outpath/bin/syncqt"
echo "QTDIR=\"$relpath\"; export QTDIR" >>"$outpath/bin/syncqt"
echo "perl \"$relpath/bin/syncqt\" -outdir \"$outpath\" $*" >>"$outpath/bin/syncqt"
chmod 755 "$outpath/bin/syncqt"
fi
# symlink the mkspecs directory
mkdir -p "$outpath/mkspecs"
rm -f "$outpath"/mkspecs/*
ln -s "$relpath"/mkspecs/* "$outpath/mkspecs"
rm -f "$outpath/mkspecs/default"
# symlink the doc directory
rm -rf "$outpath/doc"
ln -s "$relpath/doc" "$outpath/doc"
# make sure q3porting.xml can be found
mkdir -p "$outpath/tools/porting/src"
rm -f "$outpath/tools/porting/src/q3porting.xml"
ln -s "$relpath/tools/porting/src/q3porting.xml" "$outpath/tools/porting/src"
fi
# symlink fonts to be able to run application from build directory
if [ "$PLATFORM_QWS" = "yes" ] && [ ! -e "${outpath}/lib/fonts" ]; then
if [ "$PLATFORM" = "$XPLATFORM" ]; then
mkdir -p "${outpath}/lib"
ln -s "${relpath}/lib/fonts" "${outpath}/lib/fonts"
fi
fi
if [ "$OPT_FAST" = "auto" ]; then
if [ '!' -z "$AWK" ] && [ "$CFG_DEV" = "yes" ]; then
OPT_FAST=yes
else
OPT_FAST=no
fi
fi
# 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
fi ### help
#-------------------------------------------------------------------------------
# auto-detect all that hasn't been specified in the arguments
#-------------------------------------------------------------------------------
[ "$PLATFORM_QWS" = "yes" -a "$CFG_EMBEDDED" = "no" ] && CFG_EMBEDDED=auto
if [ "$CFG_EMBEDDED" != "no" ]; then
case "$UNAME_SYSTEM:$UNAME_RELEASE" in
Darwin:*)
[ -z "$PLATFORM" ] && PLATFORM=qws/macx-generic-g++
if [ -z "$XPLATFORM" ]; then
[ "$CFG_EMBEDDED" = "auto" ] && CFG_EMBEDDED=generic
XPLATFORM="qws/macx-$CFG_EMBEDDED-g++"
fi
;;
FreeBSD:*)
[ -z "$PLATFORM" ] && PLATFORM=qws/freebsd-generic-g++
if [ -z "$XPLATFORM" ]; then
[ "$CFG_EMBEDDED" = "auto" ] && CFG_EMBEDDED=generic
XPLATFORM="qws/freebsd-$CFG_EMBEDDED-g++"
fi
;;
SunOS:5*)
[ -z "$PLATFORM" ] && PLATFORM=qws/solaris-generic-g++
if [ -z "$XPLATFORM" ]; then
[ "$CFG_EMBEDDED" = "auto" ] && CFG_EMBEDDED=generic
XPLATFORM="qws/solaris-$CFG_EMBEDDED-g++"
fi
;;
Linux:*)
if [ -z "$PLATFORM" ]; then
case "$UNAME_MACHINE" in
*86)
PLATFORM=qws/linux-x86-g++
;;
*86_64)
PLATFORM=qws/linux-x86_64-g++
;;
*)
PLATFORM=qws/linux-generic-g++
;;
esac
fi
if [ -z "$XPLATFORM" ]; then
if [ "$CFG_EMBEDDED" = "auto" ]; then
if [ -n "$CFG_ARCH" ]; then
CFG_EMBEDDED=$CFG_ARCH
else
case "$UNAME_MACHINE" in
*86)
CFG_EMBEDDED=x86
;;
*86_64)
CFG_EMBEDDED=x86_64
;;
*)
CFG_EMBEDDED=generic
;;
esac
fi
fi
XPLATFORM="qws/linux-$CFG_EMBEDDED-g++"
fi
;;
QNX:*)
[ -z "$PLATFORM" ] && PLATFORM=unsupported/qws/qnx-generic-g++
if [ -z "$XPLATFORM" ]; then
[ "$CFG_EMBEDDED" = "auto" ] && CFG_EMBEDDED=generic
XPLATFORM="unsupported/qws/qnx-$CFG_EMBEDDED-g++"
fi
;;
CYGWIN*:*)
CFG_EMBEDDED=x86
;;
*)
echo "Qt for Embedded Linux is not supported on this platform. Disabling."
CFG_EMBEDDED=no
PLATFORM_QWS=no
;;
esac
fi
if [ -z "$PLATFORM" ]; then
PLATFORM_NOTES=
case "$UNAME_SYSTEM:$UNAME_RELEASE" in
Darwin:*)
if [ "$PLATFORM_MAC" = "yes" ]; then
PLATFORM=macx-g++
# PLATFORM=macx-xcode
else
PLATFORM=darwin-g++
fi
;;
AIX:*)
#PLATFORM=aix-g++
#PLATFORM=aix-g++-64
PLATFORM=aix-xlc
#PLATFORM=aix-xlc-64
PLATFORM_NOTES="
- Also available for AIX: aix-g++ aix-g++-64 aix-xlc-64
"
;;
GNU:*)
PLATFORM=hurd-g++
;;
dgux:*)
PLATFORM=dgux-g++
;;
# DYNIX/ptx:4*)
# PLATFORM=dynix-g++
# ;;
ULTRIX:*)
PLATFORM=ultrix-g++
;;
FreeBSD:*)
PLATFORM=freebsd-g++
PLATFORM_NOTES="
- Also available for FreeBSD: freebsd-icc
"
;;
OpenBSD:*)
PLATFORM=openbsd-g++
;;
NetBSD:*)
PLATFORM=netbsd-g++
;;
BSD/OS:*|BSD/386:*)
PLATFORM=bsdi-g++
;;
IRIX*:*)
#PLATFORM=irix-g++
PLATFORM=irix-cc
#PLATFORM=irix-cc-64
PLATFORM_NOTES="
- Also available for IRIX: irix-g++ irix-cc-64
"
;;
HP-UX:*)
case "$UNAME_MACHINE" in
ia64)
#PLATFORM=hpuxi-acc-32
PLATFORM=hpuxi-acc-64
PLATFORM_NOTES="
- Also available for HP-UXi: hpuxi-acc-32
"
;;
*)
#PLATFORM=hpux-g++
PLATFORM=hpux-acc
#PLATFORM=hpux-acc-64
#PLATFORM=hpux-cc
#PLATFORM=hpux-acc-o64
PLATFORM_NOTES="
- Also available for HP-UX: hpux-g++ hpux-acc-64 hpux-acc-o64
"
;;
esac
;;
OSF1:*)
#PLATFORM=tru64-g++
PLATFORM=tru64-cxx
PLATFORM_NOTES="
- Also available for Tru64: tru64-g++
"
;;
Linux:*)
case "$UNAME_MACHINE" in
x86_64|s390x|ppc64)
PLATFORM=linux-g++-64
;;
*)
PLATFORM=linux-g++
;;
esac
PLATFORM_NOTES="
- Also available for Linux: 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++
;;
*)
if [ "$OPT_HELP" != "yes" ]; then
echo
for p in $PLATFORMS; do
echo " $relconf $* -platform $p"
done
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
fi
esac
fi
if [ "$PLATFORM_QWS" = "yes" ]; then
CFG_SM=no
PLATFORMS=`find "$relpath/mkspecs/qws" | sed "s,$relpath/mkspecs/qws/,,"`
else
PLATFORMS=`find "$relpath/mkspecs/" -type f | grep -v qws | sed "s,$relpath/mkspecs/qws/,,"`
fi
[ -z "$XPLATFORM" ] && XPLATFORM="$PLATFORM"
if [ -d "$PLATFORM" ]; then
QMAKESPEC="$PLATFORM"
else
QMAKESPEC="$relpath/mkspecs/${PLATFORM}"
fi
if [ -d "$XPLATFORM" ]; then
XQMAKESPEC="$XPLATFORM"
else
XQMAKESPEC="$relpath/mkspecs/${XPLATFORM}"
fi
if [ "$PLATFORM" != "$XPLATFORM" ]; then
QT_CROSS_COMPILE=yes
QMAKE_CONFIG="$QMAKE_CONFIG cross_compile"
fi
if [ "$PLATFORM_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-g++', then if you would like to" >&2
echo " use mac-xcode on your application code it can link to a Qt/Mac" >&2
echo " built with 'macx-g++'" >&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 contact qt-bugs@trolltech.com."
echo
exit 2
fi
# now look at the configs and figure out what platform we are config'd for
[ "$CFG_EMBEDDED" = "no" ] \
&& [ '!' -z "`getQMakeConf \"$XQMAKESPEC\" | grep QMAKE_LIBS_X11 | awk '{print $3;}'`" ] \
&& PLATFORM_X11=yes
### echo "$XQMAKESPEC" | grep mkspecs/qws >/dev/null 2>&1 && PLATFORM_QWS=yes
if [ "$UNAME_SYSTEM" = "SunOS" ]; then
# Solaris 2.5 and 2.6 have libposix4, which was renamed to librt for Solaris 7 and up
if echo $UNAME_RELEASE | grep "^5\.[5|6]" >/dev/null 2>&1; then
sed -e "s,-lrt,-lposix4," "$XQMAKESPEC/qmake.conf" > "$XQMAKESPEC/qmake.conf.new"
mv "$XQMAKESPEC/qmake.conf.new" "$XQMAKESPEC/qmake.conf"
fi
fi
#-------------------------------------------------------------------------------
# determine the system architecture
#-------------------------------------------------------------------------------
if [ "$OPT_VERBOSE" = "yes" ]; then
echo "Determining system architecture... ($UNAME_SYSTEM:$UNAME_RELEASE:$UNAME_MACHINE)"
fi
if [ "$CFG_EMBEDDED" != "no" -a "$CFG_EMBEDDED" != "auto" ] && [ -n "$CFG_ARCH" ]; then
if [ "$CFG_ARCH" != "$CFG_EMBEDDED" ]; then
echo ""
echo "You have specified a target architecture with -embedded and -arch."
echo "The two architectures you have specified are different, so we can"
echo "not proceed. Either set both to be the same, or only use -embedded."
echo ""
exit 1
fi
fi
if [ -z "${CFG_HOST_ARCH}" ]; then
case "$UNAME_SYSTEM:$UNAME_RELEASE:$UNAME_MACHINE" in
IRIX*:*:*)
CFG_HOST_ARCH=`uname -p`
if [ "$OPT_VERBOSE" = "yes" ]; then
echo " SGI ($CFG_HOST_ARCH)"
fi
;;
SunOS:5*:*)
case "$UNAME_MACHINE" in
sun4u*|sun4v*)
if [ "$OPT_VERBOSE" = "yes" ]; then
echo " Sun SPARC (sparc)"
fi
CFG_HOST_ARCH=sparc
;;
i86pc)
case "$PLATFORM" in
*-64)
if [ "$OPT_VERBOSE" = "yes" ]; then
echo " 64-bit AMD 80x86 (x86_64)"
fi
CFG_HOST_ARCH=x86_64
;;
*)
if [ "$OPT_VERBOSE" = "yes" ]; then
echo " 32-bit Intel 80x86 (i386)"
fi
CFG_HOST_ARCH=i386
;;
esac
esac
;;
Darwin:*:*)
case "$UNAME_MACHINE" in
Power?Macintosh)
if [ "$OPT_VERBOSE" = "yes" ]; then
echo " 32-bit Apple PowerPC (powerpc)"
fi
;;
x86)
if [ "$OPT_VERBOSE" = "yes" ]; then
echo " 32-bit Intel 80x86 (i386)"
fi
;;
esac
CFG_HOST_ARCH=macosx
;;
AIX:*:00????????00)
if [ "$OPT_VERBOSE" = "yes" ]; then
echo " 64-bit IBM PowerPC (powerpc)"
fi
CFG_HOST_ARCH=powerpc
;;
HP-UX:*:9000*)
if [ "$OPT_VERBOSE" = "yes" ]; then
echo " HP PA-RISC (parisc)"
fi
CFG_HOST_ARCH=parisc
;;
*:*:i?86)
if [ "$OPT_VERBOSE" = "yes" ]; then
echo " 32-bit Intel 80x86 (i386)"
fi
#check symbian archirecture
if [ "$XPLATFORM" = "symbian-sbsv2" ]; then
CFG_HOST_ARCH=symbian
else
CFG_HOST_ARCH=i386
fi
;;
*:*:x86_64|*:*:amd64)
echo "x86_64|*:*:amd64"
if [ "$PLATFORM" = "linux-g++-32" -o "$PLATFORM" = "linux-icc-32" ]; then
if [ "$OPT_VERBOSE" = "yes" ]; then
echo " 32 bit on 64-bit AMD 80x86 (i386)"
fi
#check symbian archirecture
if [ "$XPLATFORM" = "symbian-sbsv2" ]; then
CFG_HOST_ARCH=symbian
else
CFG_HOST_ARCH=i386
fi
else
if [ "$OPT_VERBOSE" = "yes" ]; then
echo " 64-bit AMD 80x86 (x86_64)"
fi
#check symbian archirecture
if [ "$XPLATFORM" = "symbian-sbsv2" ]; then
CFG_HOST_ARCH=symbian
else
CFG_HOST_ARCH=x86_64
fi
fi
;;
*:*:ppc)
if [ "$OPT_VERBOSE" = "yes" ]; then
echo " 32-bit PowerPC (powerpc)"
fi
CFG_HOST_ARCH=powerpc
;;
*:*:ppc64)
if [ "$OPT_VERBOSE" = "yes" ]; then
echo " 64-bit PowerPC (powerpc)"
fi
CFG_HOST_ARCH=powerpc
;;
*:*:s390*)
if [ "$OPT_VERBOSE" = "yes" ]; then
echo " IBM S/390 (s390)"
fi
CFG_HOST_ARCH=s390
;;
*:*:arm*)
if [ "$OPT_VERBOSE" = "yes" ]; then
echo " ARM (arm)"
fi
CFG_HOST_ARCH=arm
;;
Linux:*:sparc*)
if [ "$OPT_VERBOSE" = "yes" ]; then
echo " Linux on SPARC"
fi
CFG_HOST_ARCH=sparc
;;
QNX:*:*)
case "$UNAME_MACHINE" in
x86pc)
if [ "$OPT_VERBOSE" = "yes" ]; then
echo " QNX on Intel 80x86 (i386)"
fi
CFG_HOST_ARCH=i386
;;
esac
;;
*:*:*)
if [ "$OPT_VERBOSE" = "yes" ]; then
echo " Trying '$UNAME_MACHINE'..."
fi
CFG_HOST_ARCH="$UNAME_MACHINE"
;;
esac
fi
if [ "$PLATFORM" != "$XPLATFORM" -a "$CFG_EMBEDDED" != "no" ]; then
if [ -n "$CFG_ARCH" ]; then
CFG_EMBEDDED=$CFG_ARCH
fi
case "$CFG_EMBEDDED" in
x86)
CFG_ARCH=i386
;;
x86_64)
CFG_ARCH=x86_64
;;
ipaq|sharp)
CFG_ARCH=arm
;;
dm7000)
CFG_ARCH=powerpc
;;
dm800)
CFG_ARCH=mips
;;
sh4al)
CFG_ARCH=sh4a
;;
*)
CFG_ARCH="$CFG_EMBEDDED"
;;
esac
elif [ "$PLATFORM_MAC" = "yes" ] || [ -z "$CFG_ARCH" ]; then
CFG_ARCH=$CFG_HOST_ARCH
fi
if [ -d "$relpath/src/corelib/arch/$CFG_ARCH" ]; then
if [ "$OPT_VERBOSE" = "yes" ]; then
echo " '$CFG_ARCH' is supported"
fi
else
if [ "$OPT_VERBOSE" = "yes" ]; then
echo " '$CFG_ARCH' is unsupported, using 'generic'"
fi
CFG_ARCH=generic
fi
if [ "$CFG_HOST_ARCH" != "$CFG_ARCH" ]; then
if [ -d "$relpath/src/corelib/arch/$CFG_HOST_ARCH" ]; then
if [ "$OPT_VERBOSE" = "yes" ]; then
echo " '$CFG_HOST_ARCH' is supported"
fi
else
if [ "$OPT_VERBOSE" = "yes" ]; then
echo " '$CFG_HOST_ARCH' is unsupported, using 'generic'"
fi
CFG_HOST_ARCH=generic
fi
fi
if [ "$OPT_VERBOSE" = "yes" ]; then
echo "System architecture: '$CFG_ARCH'"
if [ "$PLATFORM_QWS" = "yes" ]; then
echo "Host architecture: '$CFG_HOST_ARCH'"
fi
fi
#QTP configuration for the Symbian compilation on Linux platform
if [ "$CFG_S60" = "yes" ]; then
QMakeVar add styles "s60"
fi
#-------------------------------------------------------------------------------
# tests that don't need qmake (must be run before displaying help)
#-------------------------------------------------------------------------------
if [ -z "$PKG_CONFIG" ]; then
# See if PKG_CONFIG is set in the mkspec:
PKG_CONFIG=`getQMakeConf "$XQMAKESPEC" | sed -n -e 's%PKG_CONFIG[^_].*=%%p' | tr '\n' ' '`
fi
if [ -z "$PKG_CONFIG" ]; then
PKG_CONFIG=`"$WHICH" pkg-config 2>/dev/null`
fi
# Work out if we can use pkg-config
if [ "$QT_CROSS_COMPILE" = "yes" ]; then
if [ "$QT_FORCE_PKGCONFIG" = "yes" ]; then
echo >&2 ""
echo >&2 "You have asked to use pkg-config and are cross-compiling."
echo >&2 "Please make sure you have a correctly set-up pkg-config"
echo >&2 "environment!"
echo >&2 ""
if [ -z "$PKG_CONFIG_PATH" ]; then
echo >&2 ""
echo >&2 "Warning: PKG_CONFIG_PATH has not been set. This could mean"
echo >&2 "the host compiler's .pc files will be used. This is probably"
echo >&2 "not what you want."
echo >&2 ""
elif [ -z "$PKG_CONFIG_SYSROOT" ] && [ -z "$PKG_CONFIG_SYSROOT_DIR" ]; then
echo >&2 ""
echo >&2 "Warning: PKG_CONFIG_SYSROOT/PKG_CONFIG_SYSROOT_DIR has not"
echo >&2 "been set. This means your toolchain's .pc files must contain"
echo >&2 "the paths to the toolchain's libraries & headers. If configure"
echo >&2 "tests are failing, please check these files."
echo >&2 ""
fi
else
echo >&2 ""
echo >&2 "You have not explicitly asked to use pkg-config and are cross-compiling."
echo >&2 "pkg-config will not be used to automatically query cflag/lib parameters for"
echo >&2 "dependencies"
echo >&2 ""
PKG_CONFIG=""
fi
fi
# process CFG_MAC_ARCHS
if [ "$PLATFORM_MAC" = "yes" ]; then
# check -arch arguments for validity.
ALLOWED="x86 ppc x86_64 ppc64 i386"
# Save the list so we can re-write it using only valid values
CFG_MAC_ARCHS_IN="$CFG_MAC_ARCHS"
CFG_MAC_ARCHS=
for i in $CFG_MAC_ARCHS_IN
do
if echo "$ALLOWED" | grep -w -v "$i" > /dev/null 2>&1; then
echo "Unknown architecture: \"$i\". Supported architectures: x86[i386] ppc x86_64 ppc64";
exit 2;
fi
if [ "$i" = "i386" -o "$i" = "x86" ]; then
# These are synonymous values
# CFG_MAC_ARCHS requires x86 while GCC requires i386
CFG_MAC_ARCHS="$CFG_MAC_ARCHS x86"
MAC_CONFIG_TEST_COMMANDLINE="$MAC_CONFIG_TEST_COMMANDLINE -arch i386"
else
CFG_MAC_ARCHS="$CFG_MAC_ARCHS $i"
MAC_CONFIG_TEST_COMMANDLINE="$MAC_CONFIG_TEST_COMMANDLINE -arch $i"
fi
done
fi
# pass on $CFG_SDK to the configure tests.
if [ '!' -z "$CFG_SDK" ]; then
MAC_CONFIG_TEST_COMMANDLINE="-sdk $CFG_SDK"
fi
# find the default framework value
if [ "$PLATFORM_MAC" = "yes" ] && [ "$PLATFORM" != "macx-xlc" ]; then
if [ "$CFG_FRAMEWORK" = "auto" ]; then
CFG_FRAMEWORK="$CFG_SHARED"
elif [ "$CFG_FRAMEWORK" = "yes" ] && [ "$CFG_SHARED" = "no" ]; then
echo
echo "WARNING: Using static linking will disable the use of Mac frameworks."
echo
CFG_FRAMEWORK="no"
fi
else
CFG_FRAMEWORK=no
fi
QMAKE_CONF_COMPILER=`getQMakeConf "$XQMAKESPEC" | grep "^QMAKE_CXX[^_A-Z0-9]" | sed "s,.* *= *\(.*\)$,\1," | tail -1`
TEST_COMPILER="$CC"
[ -z "$TEST_COMPILER" ] && TEST_COMPILER=$QMAKE_CONF_COMPILER
# auto-detect precompiled header support
if [ "$CFG_PRECOMPILE" = "auto" ]; then
if [ `echo "$CFG_MAC_ARCHS" | wc -w` -gt 1 ]; then
CFG_PRECOMPILE=no
elif "$unixtests/precomp.test" "$TEST_COMPILER" "$OPT_VERBOSE"; then
CFG_PRECOMPILE=no
else
CFG_PRECOMPILE=yes
fi
elif [ "$CFG_PRECOMPILE" = "yes" ] && [ `echo "$CFG_MAC_ARCHS" | wc -w` -gt 1 ]; then
echo
echo "WARNING: Using universal binaries disables precompiled headers."
echo
CFG_PRECOMPILE=no
fi
#auto-detect DWARF2 on the mac
if [ "$PLATFORM_MAC" = "yes" ] && [ "$CFG_MAC_DWARF2" = "auto" ]; then
if "$mactests/dwarf2.test" "$TEST_COMPILER" "$OPT_VERBOSE" "$mactests" ; then
CFG_MAC_DWARF2=no
else
CFG_MAC_DWARF2=yes
fi
fi
# auto-detect support for -Xarch on the mac
if [ "$PLATFORM_MAC" = "yes" ] && [ "$CFG_MAC_XARCH" = "auto" ]; then
if "$mactests/xarch.test" "$TEST_COMPILER" "$OPT_VERBOSE" "$mactests" ; then
CFG_MAC_XARCH=no
else
CFG_MAC_XARCH=yes
fi
fi
# don't autodetect support for separate debug info on objcopy when
# cross-compiling as lots of toolchains seems to have problems with this
if [ "$QT_CROSS_COMPILE" = "yes" ] && [ "$CFG_SEPARATE_DEBUG_INFO" = "auto" ]; then
CFG_SEPARATE_DEBUG_INFO="no"
fi
# auto-detect support for separate debug info in objcopy
if [ "$CFG_SEPARATE_DEBUG_INFO" != "no" ] && [ "$CFG_SHARED" = "yes" ]; then
TEST_COMPILER_CFLAGS=`getQMakeConf "$XQMAKESPEC" | sed -n -e 's%QMAKE_CFLAGS[^_].*=%%p' | tr '\n' ' '`
TEST_COMPILER_CXXFLAGS=`getQMakeConf "$XQMAKESPEC" | sed -n -e 's%QMAKE_CXXFLAGS[^_].*=%%p' | tr '\n' ' '`
TEST_OBJCOPY=`getQMakeConf "$XQMAKESPEC" | grep "^QMAKE_OBJCOPY" | sed "s%.* *= *\(.*\)$%\1%" | tail -1`
COMPILER_WITH_FLAGS="$TEST_COMPILER $TEST_COMPILER_CXXFLAGS"
COMPILER_WITH_FLAGS=`echo "$COMPILER_WITH_FLAGS" | sed -e "s%\\$\\$QMAKE_CFLAGS%$TEST_COMPILER_CFLAGS%g"`
if "$unixtests/objcopy.test" "$COMPILER_WITH_FLAGS" "$TEST_OBJCOPY" "$OPT_VERBOSE"; then
CFG_SEPARATE_DEBUG_INFO=no
else
case "$PLATFORM" in
hpux-*)
# binutils on HP-UX is buggy; default to no.
CFG_SEPARATE_DEBUG_INFO=no
;;
*)
CFG_SEPARATE_DEBUG_INFO=yes
;;
esac
fi
fi
# auto-detect -fvisibility support
if [ "$CFG_REDUCE_EXPORTS" = "auto" ]; then
if "$unixtests/fvisibility.test" "$TEST_COMPILER" "$OPT_VERBOSE"; then
CFG_REDUCE_EXPORTS=no
else
CFG_REDUCE_EXPORTS=yes
fi
fi
# detect the availability of the -Bsymbolic-functions linker optimization
if [ "$CFG_REDUCE_RELOCATIONS" != "no" ]; then
if "$unixtests/bsymbolic_functions.test" "$TEST_COMPILER" "$OPT_VERBOSE"; then
CFG_REDUCE_RELOCATIONS=no
else
CFG_REDUCE_RELOCATIONS=yes
fi
fi
# auto-detect GNU make support
if [ "$CFG_USE_GNUMAKE" = "auto" ] && "$MAKE" -v | grep "GNU Make" >/dev/null 2>&1; then
CFG_USE_GNUMAKE=yes
fi
# If -opengl wasn't specified, don't try to auto-detect
if [ "$PLATFORM_QWS" = "yes" ] && [ "$CFG_OPENGL" = "auto" ]; then
CFG_OPENGL=no
fi
# mac
if [ "$PLATFORM_MAC" = "yes" ]; then
if [ "$CFG_OPENGL" = "auto" ] || [ "$CFG_OPENGL" = "yes" ]; then
CFG_OPENGL=desktop
fi
fi
# find the default framework value
if [ "$PLATFORM_MAC" = "yes" ] && [ "$PLATFORM" != "macx-xlc" ]; then
if [ "$CFG_FRAMEWORK" = "auto" ]; then
CFG_FRAMEWORK="$CFG_SHARED"
elif [ "$CFG_FRAMEWORK" = "yes" ] && [ "$CFG_SHARED" = "no" ]; then
echo
echo "WARNING: Using static linking will disable the use of Mac frameworks."
echo
CFG_FRAMEWORK="no"
fi
else
CFG_FRAMEWORK=no
fi
# Print a warning if configure was called with the 10.4u SDK option on Snow Leopard
# with the default mkspec. The 10.4u SDK does not support gcc 4.2.
if [ "$PLATFORM_MAC" = "yes" ] && [ '!' -z "$CFG_SDK" ]; then
# get the darwin version. 10.0.0 and up means snow leopard.
VERSION=`uname -r | tr '.' ' ' | awk '{print $1}'`
if [ "$VERSION" -gt 9 ] && [ "$CFG_SDK" == "/Developer/SDKs/MacOSX10.4u.sdk/" ] && [ "$PLATFORM" == "macx-g++" ]; then
echo
echo "WARNING: The 10.4u SDK does not support gcc 4.2. Configure with -platform macx-g++40. "
echo
fi
fi
# x11 tests are done after qmake is built
#setup the build parts
if [ -z "$CFG_BUILD_PARTS" ]; then
CFG_BUILD_PARTS="$QT_DEFAULT_BUILD_PARTS"
# don't build tools by default when cross-compiling
if [ "$PLATFORM" != "$XPLATFORM" ]; then
CFG_BUILD_PARTS=`echo "$CFG_BUILD_PARTS" | sed "s, tools,,g"`
fi
fi
for nobuild in $CFG_NOBUILD_PARTS; do
CFG_BUILD_PARTS=`echo "$CFG_BUILD_PARTS" | sed "s, $nobuild,,g"`
done
if echo $CFG_BUILD_PARTS | grep -v libs >/dev/null 2>&1; then
# echo
# echo "WARNING: libs is a required part of the build."
# echo
CFG_BUILD_PARTS="$CFG_BUILD_PARTS libs"
fi
#-------------------------------------------------------------------------------
# post process QT_INSTALL_* variables
#-------------------------------------------------------------------------------
#prefix
#For Symbian we always use install_prefix in outpath
#QT_INSTALL_PREFIX="$outpath" # In Development, we use sandboxed builds by default
QT_INSTALL_PREFIX=`"$relpath/config.tests/unix/makeabs" "$QT_INSTALL_PREFIX"`
#docs
if [ -z "$QT_INSTALL_DOCS" ]; then #default
[ -z "$QT_INSTALL_DOCS" ] && QT_INSTALL_DOCS="$QT_INSTALL_PREFIX/doc" #fallback
fi
QT_INSTALL_DOCS=`"$relpath/config.tests/unix/makeabs" "$QT_INSTALL_DOCS"`
#headers
if [ -z "$QT_INSTALL_HEADERS" ]; then #default
[ -z "$QT_INSTALL_HEADERS" ] && QT_INSTALL_HEADERS="$QT_INSTALL_PREFIX/include"
fi
QT_INSTALL_HEADERS=`"$relpath/config.tests/unix/makeabs" "$QT_INSTALL_HEADERS"`
#libs
if [ -z "$QT_INSTALL_LIBS" ]; then #default
[ -z "$QT_INSTALL_LIBS" ] && QT_INSTALL_LIBS="$QT_INSTALL_PREFIX/lib" #fallback
fi
QT_INSTALL_LIBS=`"$relpath/config.tests/unix/makeabs" "$QT_INSTALL_LIBS"`
#bins
if [ -z "$QT_INSTALL_BINS" ]; then #default
[ -z "$QT_INSTALL_BINS" ] && QT_INSTALL_BINS="$QT_INSTALL_PREFIX/bin" #fallback
fi
QT_INSTALL_BINS=`"$relpath/config.tests/unix/makeabs" "$QT_INSTALL_BINS"`
#plugins
if [ -z "$QT_INSTALL_PLUGINS" ]; then #default
[ -z "$QT_INSTALL_PLUGINS" ] && QT_INSTALL_PLUGINS="$QT_INSTALL_PREFIX/plugins" #fallback
fi
QT_INSTALL_PLUGINS=`"$relpath/config.tests/unix/makeabs" "$QT_INSTALL_PLUGINS"`
#data
if [ -z "$QT_INSTALL_DATA" ]; then #default
QT_INSTALL_DATA="$QT_INSTALL_PREFIX"
fi
QT_INSTALL_DATA=`"$relpath/config.tests/unix/makeabs" "$QT_INSTALL_DATA"`
#translations
if [ -z "$QT_INSTALL_TRANSLATIONS" ]; then #default
QT_INSTALL_TRANSLATIONS="$QT_INSTALL_PREFIX/translations"
fi
QT_INSTALL_TRANSLATIONS=`"$relpath/config.tests/unix/makeabs" "$QT_INSTALL_TRANSLATIONS"`
#settings
if [ -z "$QT_INSTALL_SETTINGS" ]; then #default
if [ "$PLATFORM_MAC" = "yes" ]; then
QT_INSTALL_SETTINGS=/Library/Preferences/Qt
else
QT_INSTALL_SETTINGS=/etc/xdg
fi
fi
QT_INSTALL_SETTINGS=`"$relpath/config.tests/unix/makeabs" "$QT_INSTALL_SETTINGS"`
#examples
if [ -z "$QT_INSTALL_EXAMPLES" ]; then #default
if [ "$CFG_PREFIX_INSTALL" = "no" ]; then
if [ "$PLATFORM_MAC" = "yes" ]; then
QT_INSTALL_EXAMPLES="/Developer/Examples/Qt"
fi
fi
[ -z "$QT_INSTALL_EXAMPLES" ] && QT_INSTALL_EXAMPLES="$QT_INSTALL_PREFIX/examples" #fallback
fi
QT_INSTALL_EXAMPLES=`"$relpath/config.tests/unix/makeabs" "$QT_INSTALL_EXAMPLES"`
#demos
if [ -z "$QT_INSTALL_DEMOS" ]; then #default
if [ "$CFG_PREFIX_INSTALL" = "no" ]; then
if [ "$PLATFORM_MAC" = "yes" ]; then
QT_INSTALL_DEMOS="/Developer/Examples/Qt/Demos"
fi
fi
[ -z "$QT_INSTALL_DEMOS" ] && QT_INSTALL_DEMOS="$QT_INSTALL_PREFIX/demos"
fi
QT_INSTALL_DEMOS=`"$relpath/config.tests/unix/makeabs" "$QT_INSTALL_DEMOS"`
#-------------------------------------------------------------------------------
# help - interactive parts of the script _after_ this section please
#-------------------------------------------------------------------------------
# next, emit a usage message if something failed.
if [ "$OPT_HELP" = "yes" ]; then
[ "x$ERROR" = "xyes" ] && echo
if [ "$CFG_NIS" = "no" ]; then
NSY=" "
NSN="*"
else
NSY="*"
NSN=" "
fi
if [ "$CFG_CUPS" = "no" ]; then
CUY=" "
CUN="*"
else
CUY="*"
CUN=" "
fi
if [ "$CFG_ICONV" = "no" ]; then
CIY=" "
CIN="*"
else
CIY="*"
CIN=" "
fi
if [ "$CFG_LARGEFILE" = "no" ]; then
LFSY=" "
LFSN="*"
else
LFSY="*"
LFSN=" "
fi
if [ "$CFG_STL" = "auto" ] || [ "$CFG_STL" = "yes" ]; then
SHY="*"
SHN=" "
else
SHY=" "
SHN="*"
fi
if [ "$CFG_IPV6" = "auto" ]; then
I6Y="*"
I6N=" "
fi
if [ "$CFG_PRECOMPILE" = "auto" ] || [ "$CFG_PRECOMPILE" = "no" ]; then
PHY=" "
PHN="*"
else
PHY="*"
PHN=" "
fi
cat <<EOF
Usage: $relconf [-h] [-prefix <dir>] [-prefix-install] [-bindir <dir>] [-libdir <dir>]
[-docdir <dir>] [-headerdir <dir>] [-plugindir <dir> ] [-datadir <dir>]
[-translationdir <dir>] [-sysconfdir <dir>] [-examplesdir <dir>]
[-demosdir <dir>] [-buildkey <key>] [-release] [-debug]
[-debug-and-release] [-developer-build] [-shared] [-static] [-no-fast] [-fast] [-no-largefile]
[-largefile] [-no-exceptions] [-exceptions] [-no-accessibility]
[-accessibility] [-no-stl] [-stl] [-no-sql-<driver>] [-sql-<driver>]
[-plugin-sql-<driver>] [-system-sqlite] [-no-qt3support] [-qt3support]
[-platform] [-D <string>] [-I <string>] [-L <string>] [-help]
[-qt-zlib] [-system-zlib] [-no-gif] [-qt-gif] [-no-libtiff] [-qt-libtiff] [-system-libtiff]
[-no-libpng] [-qt-libpng] [-system-libpng] [-no-libmng] [-qt-libmng]
[-system-libmng] [-no-libjpeg] [-qt-libjpeg] [-system-libjpeg] [-make <part>]
[-nomake <part>] [-R <string>] [-l <string>] [-no-rpath] [-rpath] [-continue]
[-verbose] [-v] [-silent] [-no-nis] [-nis] [-no-cups] [-cups] [-no-iconv]
[-iconv] [-no-pch] [-pch] [-no-dbus] [-dbus] [-dbus-linked]
[-no-separate-debug-info] [-no-mmx] [-no-3dnow] [-no-sse] [-no-sse2]
[-qtnamespace <namespace>] [-qtlibinfix <infix>] [-separate-debug-info] [-armfpa]
[-no-optimized-qmake] [-optimized-qmake] [-no-xmlpatterns] [-xmlpatterns]
[-no-multimedia] [-multimedia] [-no-phonon] [-phonon] [-no-phonon-backend] [-phonon-backend]
[-no-openssl] [-openssl] [-openssl-linked]
[-no-gtkstyle] [-gtkstyle] [-no-svg] [-svg] [-no-webkit] [-webkit] [-no-javascript-jit] [-javascript-jit]
[-no-script] [-script] [-no-scripttools] [-scripttools] [-no-declarative] [-declarative]
[additional platform specific options (see below)]
Installation options:
These are optional, but you may specify install directories.
-prefix <dir> ...... This will install everything relative to <dir>
(default $QT_INSTALL_PREFIX)
EOF
if [ "$PLATFORM_QWS" = "yes" ]; then
cat <<EOF
-hostprefix [dir] .. Tools and libraries needed when developing
applications are installed in [dir]. If [dir] is
not given, the current build directory will be used.
EOF
fi
cat <<EOF
* -prefix-install .... Force a sandboxed "local" installation of
Qt. This will install into
$QT_INSTALL_PREFIX, if this option is
disabled then some platforms will attempt a
"system" install by placing default values to
be placed in a system location other than
PREFIX.
You may use these to separate different parts of the install:
-bindir <dir> ......... Executables will be installed to <dir>
(default PREFIX/bin)
-libdir <dir> ......... Libraries will be installed to <dir>
(default PREFIX/lib)
-docdir <dir> ......... Documentation will be installed to <dir>
(default PREFIX/doc)
-headerdir <dir> ...... Headers will be installed to <dir>
(default PREFIX/include)
-plugindir <dir> ...... Plugins will be installed to <dir>
(default PREFIX/plugins)
-datadir <dir> ........ Data used by Qt programs will be installed to <dir>
(default PREFIX)
-translationdir <dir> . Translations of Qt programs will be installed to <dir>
(default PREFIX/translations)
-sysconfdir <dir> ..... Settings used by Qt programs will be looked for in <dir>
(default PREFIX/etc/settings)
-examplesdir <dir> .... Examples will be installed to <dir>
(default PREFIX/examples)
-demosdir <dir> ....... Demos will be installed to <dir>
(default PREFIX/demos)
You may use these options to turn on strict plugin loading.
-buildkey <key> .... Build the Qt library and plugins using the specified
<key>. When the library loads plugins, it will only
load those that have a matching key.
Configure options:
The defaults (*) are usually acceptable. A plus (+) denotes a default value
that needs to be evaluated. If the evaluation succeeds, the feature is
included. Here is a short explanation of each option:
* -release ........... Compile and link Qt with debugging turned off.
-debug ............. Compile and link Qt with debugging turned on.
-debug-and-release . Compile and link two versions of Qt, with and without
debugging turned on (Mac only).
-developer-build.... Compile and link Qt with Qt developer options (including auto-tests exporting)
-opensource......... Compile and link the Open-Source Edition of Qt.
-commercial......... Compile and link the Commercial Edition of Qt.
* -shared ............ Create and use shared Qt libraries.
-static ............ Create and use static Qt libraries.
* -no-fast ........... Configure Qt normally by generating Makefiles for all
project files.
-fast .............. Configure Qt quickly by generating Makefiles only for
library and subdirectory targets. All other Makefiles
are created as wrappers, which will in turn run qmake.
-no-largefile ...... Disables large file support.
+ -largefile ......... Enables Qt to access files larger than 4 GB.
EOF
if [ "$PLATFORM_QWS" = "yes" ]; then
EXCN="*"
EXCY=" "
else
EXCN=" "
EXCY="*"
fi
if [ "$CFG_DBUS" = "no" ]; then
DBY=" "
DBN="+"
else
DBY="+"
DBN=" "
fi
cat << EOF
$EXCN -no-exceptions ..... Disable exceptions on compilers that support it.
$EXCY -exceptions ........ Enable exceptions on compilers that support it.
-no-accessibility .. Do not compile Accessibility support.
* -accessibility ..... Compile Accessibility support.
$SHN -no-stl ............ Do not compile STL support.
$SHY -stl ............... Compile STL support.
-no-sql-<driver> ... Disable SQL <driver> entirely.
-qt-sql-<driver> ... Enable a SQL <driver> in the QtSql library, by default
none are turned on.
-plugin-sql-<driver> Enable SQL <driver> as a plugin to be linked to
at run time.
Possible values for <driver>:
[ $CFG_SQL_AVAILABLE ]
-system-sqlite ..... Use sqlite from the operating system.
-no-qt3support ..... Disables the Qt 3 support functionality.
* -qt3support ........ Enables the Qt 3 support functionality.
-no-xmlpatterns .... Do not build the QtXmlPatterns module.
+ -xmlpatterns ....... Build the QtXmlPatterns module.
QtXmlPatterns is built if a decent C++ compiler
is used and exceptions are enabled.
-no-multimedia ..... Do not build the QtMultimedia module.
+ -multimedia ........ Build the QtMultimedia module.
-no-phonon ......... Do not build the Phonon module.
+ -phonon ............ Build the Phonon module.
Phonon is built if a decent C++ compiler is used.
-no-phonon-backend.. Do not build the platform phonon plugin.
+ -phonon-backend..... Build the platform phonon plugin.
-no-svg ............ Do not build the SVG module.
+ -svg ............... Build the SVG module.
-no-webkit ......... Do not build the WebKit module.
+ -webkit ............ Build the WebKit module.
WebKit is built if a decent C++ compiler is used.
-no-javascript-jit . Do not build the JavaScriptCore JIT compiler.
+ -javascript-jit .... Build the JavaScriptCore JIT compiler.
-no-script ......... Do not build the QtScript module.
+ -script ............ Build the QtScript module.
-no-scripttools .... Do not build the QtScriptTools module.
+ -scripttools ....... Build the QtScriptTools module.
+ -no-declarative .....Do not build the declarative module.
-declarative ....... Build the declarative module.
-platform target ... The operating system and compiler you are building
on ($PLATFORM).
See the README file for a list of supported
operating systems and compilers.
EOF
if [ "${PLATFORM_QWS}" != "yes" ]; then
cat << EOF
-graphicssystem <sys> Sets an alternate graphics system. Available options are:
raster - Software rasterizer
opengl - Rendering via OpenGL, Experimental!
EOF
fi
cat << EOF
-no-mmx ............ Do not compile with use of MMX instructions.
-no-3dnow .......... Do not compile with use of 3DNOW instructions.
-no-sse ............ Do not compile with use of SSE instructions.
-no-sse2 ........... Do not compile with use of SSE2 instructions.
-qtnamespace <name> Wraps all Qt library code in 'namespace <name> {...}'.
-qtlibinfix <infix> Renames all libQt*.so to libQt*<infix>.so.
-D <string> ........ Add an explicit define to the preprocessor.
-I <string> ........ Add an explicit include path.
-L <string> ........ Add an explicit library path.
-help, -h .......... Display this information.
Third Party Libraries:
-qt-zlib ........... Use the zlib bundled with Qt.
+ -system-zlib ....... Use zlib from the operating system.
See http://www.gzip.org/zlib
-no-gif ............ Do not compile the plugin for GIF reading support.
* -qt-gif ............ Compile the plugin for GIF reading support.
See also src/plugins/imageformats/gif/qgifhandler.h
-no-libtiff ........ Do not compile the plugin for TIFF support.
-qt-libtiff ........ Use the libtiff bundled with Qt.
+ -system-libtiff .... Use libtiff from the operating system.
See http://www.libtiff.org
-no-libpng ......... Do not compile in PNG support.
-qt-libpng ......... Use the libpng bundled with Qt.
+ -system-libpng ..... Use libpng from the operating system.
See http://www.libpng.org/pub/png
-no-libmng ......... Do not compile the plugin for MNG support.
-qt-libmng ......... Use the libmng bundled with Qt.
+ -system-libmng ..... Use libmng from the operating system.
See http://www.libmng.com
-no-libjpeg ........ Do not compile the plugin for JPEG support.
-qt-libjpeg ........ Use the libjpeg bundled with Qt.
+ -system-libjpeg .... Use libjpeg from the operating system.
See http://www.ijg.org
-no-openssl ........ Do not compile support for OpenSSL.
+ -openssl ........... Enable run-time OpenSSL support.
-openssl-linked .... Enabled linked OpenSSL support.
-ptmalloc .......... Override the system memory allocator with ptmalloc.
(Experimental.)
Additional options:
-make <part> ....... Add part to the list of parts to be built at make time.
($QT_DEFAULT_BUILD_PARTS)
-nomake <part> ..... Exclude part from the list of parts to be built.
-R <string> ........ Add an explicit runtime library path to the Qt
libraries.
-l <string> ........ Add an explicit library.
-no-rpath .......... Do not use the library install path as a runtime
library path.
+ -rpath ............. Link Qt libraries and executables using the library
install path as a runtime library path. Equivalent
to -R install_libpath
-continue .......... Continue as far as possible if an error occurs.
-verbose, -v ....... Print verbose information about each step of the
configure process.
-silent ............ Reduce the build output so that warnings and errors
can be seen more easily.
* -no-optimized-qmake ... Do not build qmake optimized.
-optimized-qmake ...... Build qmake optimized.
$NSN -no-nis ............ Do not compile NIS support.
$NSY -nis ............... Compile NIS support.
$CUN -no-cups ........... Do not compile CUPS support.
$CUY -cups .............. Compile CUPS support.
Requires cups/cups.h and libcups.so.2.
$CIN -no-iconv .......... Do not compile support for iconv(3).
$CIY -iconv ............. Compile support for iconv(3).
$PHN -no-pch ............ Do not use precompiled header support.
$PHY -pch ............... Use precompiled header support.
$DBN -no-dbus ........... Do not compile the QtDBus module.
$DBY -dbus .............. Compile the QtDBus module and dynamically load libdbus-1.
-dbus-linked ....... Compile the QtDBus module and link to libdbus-1.
-reduce-relocations ..... Reduce relocations in the libraries through extra
linker optimizations (Qt/X11 and Qt for Embedded Linux only;
experimental; needs GNU ld >= 2.18).
EOF
if [ "$CFG_SEPARATE_DEBUG_INFO" = "auto" ]; then
if [ "$QT_CROSS_COMPILE" = "yes" ]; then
SBY=""
SBN="*"
else
SBY="*"
SBN=" "
fi
elif [ "$CFG_SEPARATE_DEBUG_INFO" = "yes" ]; then
SBY="*"
SBN=" "
else
SBY=" "
SBN="*"
fi
if [ "$PLATFORM_X11" = "yes" -o "$PLATFORM_QWS" = "yes" ]; then
cat << EOF
$SBN -no-separate-debug-info . Do not store debug information in a separate file.
$SBY -separate-debug-info .... Strip debug information into a separate .debug file.
EOF
fi # X11/QWS
if [ "$PLATFORM_X11" = "yes" ]; then
if [ "$CFG_SM" = "no" ]; then
SMY=" "
SMN="*"
else
SMY="*"
SMN=" "
fi
if [ "$CFG_XSHAPE" = "no" ]; then
SHY=" "
SHN="*"
else
SHY="*"
SHN=" "
fi
if [ "$CFG_XINERAMA" = "no" ]; then
XAY=" "
XAN="*"
else
XAY="*"
XAN=" "
fi
if [ "$CFG_FONTCONFIG" = "no" ]; then
FCGY=" "
FCGN="*"
else
FCGY="*"
FCGN=" "
fi
if [ "$CFG_XCURSOR" = "no" ]; then
XCY=" "
XCN="*"
else
XCY="*"
XCN=" "
fi
if [ "$CFG_XFIXES" = "no" ]; then
XFY=" "
XFN="*"
else
XFY="*"
XFN=" "
fi
if [ "$CFG_XRANDR" = "no" ]; then
XZY=" "
XZN="*"
else
XZY="*"
XZN=" "
fi
if [ "$CFG_XRENDER" = "no" ]; then
XRY=" "
XRN="*"
else
XRY="*"
XRN=" "
fi
if [ "$CFG_MITSHM" = "no" ]; then
XMY=" "
XMN="*"
else
XMY="*"
XMN=" "
fi
if [ "$CFG_XINPUT" = "no" ]; then
XIY=" "
XIN="*"
else
XIY="*"
XIN=" "
fi
if [ "$CFG_XKB" = "no" ]; then
XKY=" "
XKN="*"
else
XKY="*"
XKN=" "
fi
if [ "$CFG_IM" = "no" ]; then
IMY=" "
IMN="*"
else
IMY="*"
IMN=" "
fi
cat << EOF
Qt/X11 only:
-no-gtkstyle ....... Do not build the GTK theme integration.
+ -gtkstyle .......... Build the GTK theme integration.
* -no-nas-sound ...... Do not compile in NAS sound support.
-system-nas-sound .. Use NAS libaudio from the operating system.
See http://radscan.com/nas.html
-no-opengl ......... Do not support OpenGL.
+ -opengl <api> ...... Enable OpenGL support.
With no parameter, this will auto-detect the "best"
OpenGL API to use. If desktop OpenGL is avaliable, it
will be used. Use desktop, es1, es1cl or es2 for <api>
to force the use of the Desktop (OpenGL 1.x or 2.x),
OpenGL ES 1.x Common profile, 1.x Common Lite profile
or 2.x APIs instead. On X11, the EGL API will be used
to manage GL contexts in the case of OpenGL ES
-no-openvg ........ Do not support OpenVG.
+ -openvg ........... Enable OpenVG support.
Requires EGL support, typically supplied by an OpenGL
or other graphics implementation.
$SMN -no-sm ............. Do not support X Session Management.
$SMY -sm ................ Support X Session Management, links in -lSM -lICE.
$SHN -no-xshape ......... Do not compile XShape support.
$SHY -xshape ............ Compile XShape support.
Requires X11/extensions/shape.h.
$SHN -no-xsync .......... Do not compile XSync support.
$SHY -xsync ............. Compile XSync support.
Requires X11/extensions/sync.h.
$XAN -no-xinerama ....... Do not compile Xinerama (multihead) support.
$XAY -xinerama .......... Compile Xinerama support.
Requires X11/extensions/Xinerama.h and libXinerama.
By default, Xinerama support will be compiled if
available and the shared libraries are dynamically
loaded at runtime.
$XCN -no-xcursor ........ Do not compile Xcursor support.
$XCY -xcursor ........... Compile Xcursor support.
Requires X11/Xcursor/Xcursor.h and libXcursor.
By default, Xcursor support will be compiled if
available and the shared libraries are dynamically
loaded at runtime.
$XFN -no-xfixes ......... Do not compile Xfixes support.
$XFY -xfixes ............ Compile Xfixes support.
Requires X11/extensions/Xfixes.h and libXfixes.
By default, Xfixes support will be compiled if
available and the shared libraries are dynamically
loaded at runtime.
$XZN -no-xrandr ......... Do not compile Xrandr (resize and rotate) support.
$XZY -xrandr ............ Compile Xrandr support.
Requires X11/extensions/Xrandr.h and libXrandr.
$XRN -no-xrender ........ Do not compile Xrender support.
$XRY -xrender ........... Compile Xrender support.
Requires X11/extensions/Xrender.h and libXrender.
$XMN -no-mitshm ......... Do not compile MIT-SHM support.
$XMY -mitshm ............ Compile MIT-SHM support.
Requires sys/ipc.h, sys/shm.h and X11/extensions/XShm.h
$FCGN -no-fontconfig ..... Do not compile FontConfig (anti-aliased font) support.
$FCGY -fontconfig ........ Compile FontConfig support.
Requires fontconfig/fontconfig.h, libfontconfig,
freetype.h and libfreetype.
$XIN -no-xinput.......... Do not compile Xinput support.
$XIY -xinput ............ Compile Xinput support. This also enabled tablet support
which requires IRIX with wacom.h and libXi or
XFree86 with X11/extensions/XInput.h and libXi.
$XKN -no-xkb ............ Do not compile XKB (X KeyBoard extension) support.
$XKY -xkb ............... Compile XKB support.
EOF
fi
if [ "$PLATFORM_MAC" = "yes" ]; then
cat << EOF
Qt/Mac only:
-Fstring ........... Add an explicit framework path.
-fw string ......... Add an explicit framework.
-cocoa ............. Build the Cocoa version of Qt. Note that -no-framework
and -static is not supported with -cocoa. Specifying
this option creates Qt binaries that requires Mac OS X
10.5 or higher.
* -framework ......... Build Qt as a series of frameworks and
link tools against those frameworks.
-no-framework ...... Do not build Qt as a series of frameworks.
* -dwarf2 ............ Enable dwarf2 debugging symbols.
-no-dwarf2 ......... Disable dwarf2 debugging symbols.
-universal ......... Equivalent to -arch "ppc x86"
-arch <arch> ....... Build Qt for <arch>
Example values for <arch>: x86 ppc x86_64 ppc64
Multiple -arch arguments can be specified, 64-bit archs
will be built with the Cocoa framework.
-sdk <sdk> ......... Build Qt using Apple provided SDK <sdk>. This option requires gcc 4.
To use a different SDK with gcc 3.3, set the SDKROOT environment variable.
EOF
fi
if [ "$PLATFORM_QWS" = "yes" ]; then
cat << EOF
Qt for Embedded Linux only:
-xplatform target ... The target platform when cross-compiling.
-no-feature-<feature> Do not compile in <feature>.
-feature-<feature> .. Compile in <feature>. The available features
are described in src/corelib/global/qfeatures.txt
-embedded <arch> .... This will enable the embedded build, you must have a
proper license for this switch to work.
Example values for <arch>: arm mips x86 generic
-armfpa ............. Target platform uses the ARM-FPA floating point format.
-no-armfpa .......... Target platform does not use the ARM-FPA floating point format.
The floating point format is usually autodetected by configure. Use this
to override the detected value.
-little-endian ...... Target platform is little endian (LSB first).
-big-endian ......... Target platform is big endian (MSB first).
-host-little-endian . Host platform is little endian (LSB first).
-host-big-endian .... Host platform is big endian (MSB first).
You only need to specify the endianness when
cross-compiling, otherwise the host
endianness will be used.
-no-freetype ........ Do not compile in Freetype2 support.
-qt-freetype ........ Use the libfreetype bundled with Qt.
* -system-freetype .... Use libfreetype from the operating system.
See http://www.freetype.org/
-qconfig local ...... Use src/corelib/global/qconfig-local.h rather than the
default ($CFG_QCONFIG).
-depths <list> ...... Comma-separated list of supported bit-per-pixel
depths, from: 1, 4, 8, 12, 15, 16, 18, 24, 32 and 'all'.
-qt-decoration-<style> ....Enable a decoration <style> in the QtGui library,
by default all available decorations are on.
Possible values for <style>: [ $CFG_DECORATION_AVAILABLE ]
-plugin-decoration-<style> Enable decoration <style> as a plugin to be
linked to at run time.
Possible values for <style>: [ $CFG_DECORATION_PLUGIN_AVAILABLE ]
-no-decoration-<style> ....Disable decoration <style> entirely.
Possible values for <style>: [ $CFG_DECORATION_AVAILABLE ]
-no-opengl .......... Do not support OpenGL.
-opengl <api> ....... Enable OpenGL ES support
With no parameter, this will attempt to auto-detect OpenGL ES 1.x
or 2.x. Use es1, es1cl or es2 for <api> to override auto-detection.
NOTE: A QGLScreen driver for the hardware is required to support
OpenGL ES on Qt for Embedded Linux.
-qt-gfx-<driver> ... Enable a graphics <driver> in the QtGui library.
Possible values for <driver>: [ $CFG_GFX_AVAILABLE ]
-plugin-gfx-<driver> Enable graphics <driver> as a plugin to be
linked to at run time.
Possible values for <driver>: [ $CFG_GFX_PLUGIN_AVAILABLE ]
-no-gfx-<driver> ... Disable graphics <driver> entirely.
Possible values for <driver>: [ $CFG_GFX_AVAILABLE ]
-qt-kbd-<driver> ... Enable a keyboard <driver> in the QtGui library.
Possible values for <driver>: [ $CFG_KBD_AVAILABLE ]
-plugin-kbd-<driver> Enable keyboard <driver> as a plugin to be linked to
at runtime.
Possible values for <driver>: [ $CFG_KBD_PLUGIN_AVAILABLE ]
-no-kbd-<driver> ... Disable keyboard <driver> entirely.
Possible values for <driver>: [ $CFG_KBD_AVAILABLE ]
-qt-mouse-<driver> ... Enable a mouse <driver> in the QtGui library.
Possible values for <driver>: [ $CFG_MOUSE_AVAILABLE ]
-plugin-mouse-<driver> Enable mouse <driver> as a plugin to be linked to
at runtime.
Possible values for <driver>: [ $CFG_MOUSE_PLUGIN_AVAILABLE ]
-no-mouse-<driver> ... Disable mouse <driver> entirely.
Possible values for <driver>: [ $CFG_MOUSE_AVAILABLE ]
-iwmmxt ............ Compile using the iWMMXt instruction set
(available on some XScale CPUs).
EOF
fi
if [ "$XPLATFORM"="symbian-sbsv2" ]; then
-no-s60..............Do not compile in S60 support.
-s60.................Compile with support for the S60 UI Framework
-no-usedeffiles......Disable the usage of DEF files.
-usedeffiles.........Enable the usage of DEF files.
cat << EOF
EOF
fi
if [ "$PLATFORM_QWS" = "yes" -o "$PLATFORM_X11" = "yes" ]; then
if [ "$CFG_GLIB" = "no" ]; then
GBY=" "
GBN="+"
else
GBY="+"
GBN=" "
fi
cat << EOF
$GBN -no-glib ........... Do not compile Glib support.
$GBY -glib .............. Compile Glib support.
EOF
fi
# QTP:QTPROD-7 Cross compiling on Linux broken
if [ "$XPLATFORM" = "symbian-sbsv2" ]; then
cat << EOF
Qt for Symbian only:
-no-style-s60....... Disable s60 entirely
-qt-style-s60....... Enable s60 in the Qt Library
EOF
fi
[ "x$ERROR" = "xyes" ] && exit 1
exit 0
fi # Help
# -----------------------------------------------------------------------------
# LICENSING, INTERACTIVE PART
# -----------------------------------------------------------------------------
if [ "$PLATFORM_QWS" = "yes" ]; then
Platform="Qt for Embedded Linux"
elif [ "$PLATFORM_MAC" = "yes" ]; then
Platform="Qt/Mac"
elif [ "$XPLATFORM" = "symbian-sbsv2" ]; then
Platform="Qt/Symbian"
else
PLATFORM_X11=yes
Platform="Qt/X11"
fi
echo
echo "This is the $Platform ${EditionString} Edition."
echo
if [ "$Edition" = "NokiaInternalBuild" ]; then
echo "Detected -nokia-developer option"
echo "Nokia employees and agents are allowed to use this software under"
echo "the authority of Nokia Corporation and/or its subsidiary(-ies)"
elif [ "$Edition" = "OpenSource" ]; then
while true; do
echo "You are licensed to use this software under the terms of"
echo "the Lesser GNU General Public License (LGPL) versions 2.1."
if [ -f "$relpath/LICENSE.GPL3" ]; then
echo "You are also licensed to use this software under the terms of"
echo "the GNU General Public License (GPL) versions 3."
affix="either"
else
affix="the"
fi
echo
if [ "$OPT_CONFIRM_LICENSE" = "yes" ]; then
echo "You have already accepted the terms of the $LicenseType license."
acceptance=yes
else
if [ -f "$relpath/LICENSE.GPL3" ]; then
echo "Type '3' to view the GNU General Public License version 3."
fi
echo "Type 'L' to view the Lesser GNU General Public License version 2.1."
echo "Type 'yes' to accept this license offer."
echo "Type 'no' to decline this license offer."
echo
if echo '\c' | grep '\c' >/dev/null; then
echo -n "Do you accept the terms of $affix license? "
else
echo "Do you accept the terms of $affix license? \c"
fi
read acceptance
fi
echo
if [ "$acceptance" = "yes" ] || [ "$acceptance" = "y" ]; then
break
elif [ "$acceptance" = "no" ]; then
echo "You are not licensed to use this software."
echo
exit 1
elif [ "$acceptance" = "3" ]; then
more "$relpath/LICENSE.GPL3"
elif [ "$acceptance" = "L" ]; then
more "$relpath/LICENSE.LGPL"
fi
done
elif [ "$Edition" = "Preview" ]; then
TheLicense=`head -n 1 "$relpath/LICENSE.PREVIEW.COMMERCIAL"`
while true; do
if [ "$OPT_CONFIRM_LICENSE" = "yes" ]; then
echo "You have already accepted the terms of the $LicenseType license."
acceptance=yes
else
echo "You are licensed to use this software under the terms of"
echo "the $TheLicense"
echo
echo "Type '?' to read the Preview License."
echo "Type 'yes' to accept this license offer."
echo "Type 'no' to decline this license offer."
echo
if echo '\c' | grep '\c' >/dev/null; then
echo -n "Do you accept the terms of the license? "
else
echo "Do you accept the terms of the license? \c"
fi
read acceptance
fi
echo
if [ "$acceptance" = "yes" ]; then
break
elif [ "$acceptance" = "no" ] ;then
echo "You are not licensed to use this software."
echo
exit 0
elif [ "$acceptance" = "?" ]; then
more "$relpath/LICENSE.PREVIEW.COMMERCIAL"
fi
done
elif [ "$Edition" != "OpenSource" ]; then
if [ -n "$ExpiryDate" ]; then
ExpiryDate=`echo $ExpiryDate | sed -e "s,-,,g" | tr -d "\n\r"`
[ -z "$ExpiryDate" ] && ExpiryDate="0"
Today=`date +%Y%m%d`
if [ "$Today" -gt "$ExpiryDate" ]; then
case "$LicenseType" in
Commercial|Academic|Educational)
if [ "$QT_PACKAGEDATE" -gt "$ExpiryDate" ]; then
echo
echo "NOTICE NOTICE NOTICE NOTICE"
echo
echo " Your support and upgrade period has expired."
echo
echo " You are no longer licensed to use this version of Qt."
echo " Please contact qt-info@nokia.com to renew your support"
echo " and upgrades for this license."
echo
echo "NOTICE NOTICE NOTICE NOTICE"
echo
exit 1
else
echo
echo "WARNING WARNING WARNING WARNING"
echo
echo " Your support and upgrade period has expired."
echo
echo " You may continue to use your last licensed release"
echo " of Qt under the terms of your existing license"
echo " agreement. But you are not entitled to technical"
echo " support, nor are you entitled to use any more recent"
echo " Qt releases."
echo
echo " Please contact qt-info@nokia.com to renew your"
echo " support and upgrades for this license."
echo
echo "WARNING WARNING WARNING WARNING"
echo
sleep 3
fi
;;
Evaluation|*)
echo
echo "NOTICE NOTICE NOTICE NOTICE"
echo
echo " Your Evaluation license has expired."
echo
echo " You are no longer licensed to use this software. Please"
echo " contact qt-info@nokia.com to purchase license, or install"
echo " the Qt Open Source Edition if you intend to develop free"
echo " software."
echo
echo "NOTICE NOTICE NOTICE NOTICE"
echo
exit 1
;;
esac
fi
fi
TheLicense=`head -n 1 "$outpath/LICENSE"`
while true; do
if [ "$OPT_CONFIRM_LICENSE" = "yes" ]; then
echo "You have already accepted the terms of the $TheLicense."
acceptance=yes
else
echo "You are licensed to use this software under the terms of"
echo "the $TheLicense."
echo
echo "Type '?' to view the $TheLicense."
echo "Type 'yes' to accept this license offer."
echo "Type 'no' to decline this license offer."
echo
if echo '\c' | grep '\c' >/dev/null; then
echo -n "Do you accept the terms of the $TheLicense? "
else
echo "Do you accept the terms of the $TheLicense? \c"
fi
read acceptance
fi
echo
if [ "$acceptance" = "yes" ]; then
break
elif [ "$acceptance" = "no" ]; then
echo "You are not licensed to use this software."
echo
exit 1
else [ "$acceptance" = "?" ]
more "$outpath/LICENSE"
fi
done
fi
# this should be moved somewhere else
case "$PLATFORM" in
aix-*)
AIX_VERSION=`uname -v`
if [ "$AIX_VERSION" -lt "5" ]; then
QMakeVar add QMAKE_LIBS_X11 -lbind
fi
;;
*)
;;
esac
#-------------------------------------------------------------------------------
# generate qconfig.cpp
#-------------------------------------------------------------------------------
[ -d "$outpath/src/corelib/global" ] || mkdir -p "$outpath/src/corelib/global"
LICENSE_USER_STR=`"$relpath/config.tests/unix/padstring" 268 "qt_lcnsuser=$Licensee"`
LICENSE_PRODUCTS_STR=`"$relpath/config.tests/unix/padstring" 268 "qt_lcnsprod=$Edition"`
PREFIX_PATH_STR=`"$relpath/config.tests/unix/padstring" 268 "qt_prfxpath=$QT_INSTALL_PREFIX"`
DOCUMENTATION_PATH_STR=`"$relpath/config.tests/unix/padstring" 268 "qt_docspath=$QT_INSTALL_DOCS"`
HEADERS_PATH_STR=`"$relpath/config.tests/unix/padstring" 268 "qt_hdrspath=$QT_INSTALL_HEADERS"`
LIBRARIES_PATH_STR=`"$relpath/config.tests/unix/padstring" 268 "qt_libspath=$QT_INSTALL_LIBS"`
BINARIES_PATH_STR=`"$relpath/config.tests/unix/padstring" 268 "qt_binspath=$QT_INSTALL_BINS"`
PLUGINS_PATH_STR=`"$relpath/config.tests/unix/padstring" 268 "qt_plugpath=$QT_INSTALL_PLUGINS"`
DATA_PATH_STR=`"$relpath/config.tests/unix/padstring" 268 "qt_datapath=$QT_INSTALL_DATA"`
TRANSLATIONS_PATH_STR=`"$relpath/config.tests/unix/padstring" 268 "qt_trnspath=$QT_INSTALL_TRANSLATIONS"`
SETTINGS_PATH_STR=`"$relpath/config.tests/unix/padstring" 268 "qt_stngpath=$QT_INSTALL_SETTINGS"`
EXAMPLES_PATH_STR=`"$relpath/config.tests/unix/padstring" 268 "qt_xmplpath=$QT_INSTALL_EXAMPLES"`
DEMOS_PATH_STR=`"$relpath/config.tests/unix/padstring" 268 "qt_demopath=$QT_INSTALL_DEMOS"`
TODAY=`date +%Y-%m-%d`
cat > "$outpath/src/corelib/global/qconfig.cpp.new" <<EOF
/* License Info */
static const char qt_configure_licensee_str [256 + 12] = "$LICENSE_USER_STR";
static const char qt_configure_licensed_products_str [256 + 12] = "$LICENSE_PRODUCTS_STR";
/* Installation date */
static const char qt_configure_installation [12+11] = "qt_instdate=$TODAY";
EOF
if [ ! -z "$QT_HOST_PREFIX" ]; then
HOSTPREFIX_PATH_STR=`"$relpath/config.tests/unix/padstring" 268 "qt_prfxpath=$QT_HOST_PREFIX"`
HOSTDOCUMENTATION_PATH_STR=`"$relpath/config.tests/unix/padstring" 268 "qt_docspath=$QT_HOST_PREFIX/doc"`
HOSTHEADERS_PATH_STR=`"$relpath/config.tests/unix/padstring" 268 "qt_hdrspath=$QT_HOST_PREFIX/include"`
HOSTLIBRARIES_PATH_STR=`"$relpath/config.tests/unix/padstring" 268 "qt_libspath=$QT_HOST_PREFIX/lib"`
HOSTBINARIES_PATH_STR=`"$relpath/config.tests/unix/padstring" 268 "qt_binspath=$QT_HOST_PREFIX/bin"`
HOSTPLUGINS_PATH_STR=`"$relpath/config.tests/unix/padstring" 268 "qt_plugpath=$QT_HOST_PREFIX/plugins"`
HOSTDATA_PATH_STR=`"$relpath/config.tests/unix/padstring" 268 "qt_datapath=$QT_HOST_PREFIX"`
HOSTTRANSLATIONS_PATH_STR=`"$relpath/config.tests/unix/padstring" 268 "qt_trnspath=$QT_HOST_PREFIX/translations"`
HOSTSETTINGS_PATH_STR=`"$relpath/config.tests/unix/padstring" 268 "qt_stngpath=$QT_INSTALL_SETTINGS"`
HOSTEXAMPLES_PATH_STR=`"$relpath/config.tests/unix/padstring" 268 "qt_xmplpath=$QT_INSTALL_EXAMPLES"`
HOSTDEMOS_PATH_STR=`"$relpath/config.tests/unix/padstring" 268 "qt_demopath=$QT_INSTALL_DEMOS"`
cat >> "$outpath/src/corelib/global/qconfig.cpp.new" <<EOF
#if defined(QT_BOOTSTRAPPED) || defined(QT_BUILD_QMAKE)
/* Installation Info */
static const char qt_configure_prefix_path_str [256 + 12] = "$HOSTPREFIX_PATH_STR";
static const char qt_configure_documentation_path_str[256 + 12] = "$HOSTDOCUMENTATION_PATH_STR";
static const char qt_configure_headers_path_str [256 + 12] = "$HOSTHEADERS_PATH_STR";
static const char qt_configure_libraries_path_str [256 + 12] = "$HOSTLIBRARIES_PATH_STR";
static const char qt_configure_binaries_path_str [256 + 12] = "$HOSTBINARIES_PATH_STR";
static const char qt_configure_plugins_path_str [256 + 12] = "$HOSTPLUGINS_PATH_STR";
static const char qt_configure_data_path_str [256 + 12] = "$HOSTDATA_PATH_STR";
static const char qt_configure_translations_path_str [256 + 12] = "$HOSTTRANSLATIONS_PATH_STR";
static const char qt_configure_settings_path_str [256 + 12] = "$HOSTSETTINGS_PATH_STR";
static const char qt_configure_examples_path_str [256 + 12] = "$HOSTEXAMPLES_PATH_STR";
static const char qt_configure_demos_path_str [256 + 12] = "$HOSTDEMOS_PATH_STR";
#else // QT_BOOTSTRAPPED
EOF
fi
cat >> "$outpath/src/corelib/global/qconfig.cpp.new" <<EOF
/* Installation Info */
static const char qt_configure_prefix_path_str [256 + 12] = "$PREFIX_PATH_STR";
static const char qt_configure_documentation_path_str[256 + 12] = "$DOCUMENTATION_PATH_STR";
static const char qt_configure_headers_path_str [256 + 12] = "$HEADERS_PATH_STR";
static const char qt_configure_libraries_path_str [256 + 12] = "$LIBRARIES_PATH_STR";
static const char qt_configure_binaries_path_str [256 + 12] = "$BINARIES_PATH_STR";
static const char qt_configure_plugins_path_str [256 + 12] = "$PLUGINS_PATH_STR";
static const char qt_configure_data_path_str [256 + 12] = "$DATA_PATH_STR";
static const char qt_configure_translations_path_str [256 + 12] = "$TRANSLATIONS_PATH_STR";
static const char qt_configure_settings_path_str [256 + 12] = "$SETTINGS_PATH_STR";
static const char qt_configure_examples_path_str [256 + 12] = "$EXAMPLES_PATH_STR";
static const char qt_configure_demos_path_str [256 + 12] = "$DEMOS_PATH_STR";
EOF
if [ ! -z "$QT_HOST_PREFIX" ]; then
cat >> "$outpath/src/corelib/global/qconfig.cpp.new" <<EOF
#endif // QT_BOOTSTRAPPED
EOF
fi
cat >> "$outpath/src/corelib/global/qconfig.cpp.new" <<EOF
/* strlen( "qt_lcnsxxxx" ) == 12 */
#define QT_CONFIGURE_LICENSEE qt_configure_licensee_str + 12;
#define QT_CONFIGURE_LICENSED_PRODUCTS qt_configure_licensed_products_str + 12;
#define QT_CONFIGURE_PREFIX_PATH qt_configure_prefix_path_str + 12;
#define QT_CONFIGURE_DOCUMENTATION_PATH qt_configure_documentation_path_str + 12;
#define QT_CONFIGURE_HEADERS_PATH qt_configure_headers_path_str + 12;
#define QT_CONFIGURE_LIBRARIES_PATH qt_configure_libraries_path_str + 12;
#define QT_CONFIGURE_BINARIES_PATH qt_configure_binaries_path_str + 12;
#define QT_CONFIGURE_PLUGINS_PATH qt_configure_plugins_path_str + 12;
#define QT_CONFIGURE_DATA_PATH qt_configure_data_path_str + 12;
#define QT_CONFIGURE_TRANSLATIONS_PATH qt_configure_translations_path_str + 12;
#define QT_CONFIGURE_SETTINGS_PATH qt_configure_settings_path_str + 12;
#define QT_CONFIGURE_EXAMPLES_PATH qt_configure_examples_path_str + 12;
#define QT_CONFIGURE_DEMOS_PATH qt_configure_demos_path_str + 12;
EOF
# avoid unecessary rebuilds by copying only if qconfig.cpp has changed
if cmp -s "$outpath/src/corelib/global/qconfig.cpp" "$outpath/src/corelib/global/qconfig.cpp.new"; then
rm -f "$outpath/src/corelib/global/qconfig.cpp.new"
else
[ -f "$outpath/src/corelib/global/qconfig.cpp" ] && chmod +w "$outpath/src/corelib/global/qconfig.cpp"
mv "$outpath/src/corelib/global/qconfig.cpp.new" "$outpath/src/corelib/global/qconfig.cpp"
chmod -w "$outpath/src/corelib/global/qconfig.cpp"
fi
# -----------------------------------------------------------------------------
if [ "$LicenseType" = "Evaluation" ]; then
EVALKEY=`"$relpath/config.tests/unix/padstring" 524 "qt_qevalkey=$LicenseKeyExt"`
elif echo "$D_FLAGS" | grep QT_EVAL >/dev/null 2>&1; then
EVALKEY=`"$relpath/config.tests/unix/padstring" 524 "qt_qevalkey="`
fi
if [ -n "$EVALKEY" ]; then
rm -f "$outpath/src/corelib/global/qconfig_eval.cpp"
cat > "$outpath/src/corelib/global/qconfig_eval.cpp" <<EOF
/* Evaluation license key */
static const char qt_eval_key_data [512 + 12] = "$EVALKEY";
EOF
chmod -w "$outpath/src/corelib/global/qconfig_eval.cpp"
fi
# -----------------------------------------------------------------------------
# build qmake
# -----------------------------------------------------------------------------
# symlink includes
if [ -n "$PERL" ] && [ -x "$relpath/bin/syncqt" ]; then
SYNCQT_OPTS=
[ "$CFG_DEV" = "yes" ] && SYNCQT_OPTS="$SYNCQT_OPTS -check-includes"
if [ "$OPT_SHADOW" = "yes" ]; then
"$outpath/bin/syncqt" $SYNCQT_OPTS
elif [ "$CFG_DEV" = "yes" ] || [ ! -d $relpath/include ]; then
QTDIR="$relpath" perl "$outpath/bin/syncqt" $SYNCQT_OPTS
fi
fi
# $1: variable name
# $2: optional transformation
# relies on $QMAKESPEC, $COMPILER_CONF and $mkfile being set correctly, as the latter
# is where the resulting variable is written to
setBootstrapVariable()
{
variableRegExp="^$1[^_A-Z0-9]"
getQMakeConf | grep "$variableRegExp" | ( [ -n "$2" ] && sed "$2" ; [ -z "$2" ] && cat ) | $AWK '
{
varLength = index($0, "=") - 1
valStart = varLength + 2
if (substr($0, varLength, 1) == "+") {
varLength = varLength - 1
valStart = valStart + 1
}
var = substr($0, 0, varLength)
gsub("[ \t]+", "", var)
val = substr($0, valStart)
printf "%s_%s = %s\n", var, NR, val
}
END {
if (length(var) > 0) {
printf "%s =", var
for (i = 1; i <= NR; ++i)
printf " $(%s_%s)", var, i
printf "\n"
}
}' >> "$mkfile"
}
# build qmake
if true; then ###[ '!' -f "$outpath/bin/qmake" ];
echo "Creating qmake. Please wait..."
OLD_QCONFIG_H=
QCONFIG_H="$outpath/src/corelib/global/qconfig.h"
QMAKE_QCONFIG_H="${QCONFIG_H}.qmake"
if [ -f "$QCONFIG_H" ]; then
OLD_QCONFIG_H=$QCONFIG_H
mv -f "$OLD_QCONFIG_H" "${OLD_QCONFIG_H}.old"
fi
# create temporary qconfig.h for compiling qmake, if it doesn't exist
# when building qmake, we use #defines for the install paths,
# however they are real functions in the library
if [ '!' -f "$QMAKE_QCONFIG_H" ]; then
mkdir -p "$outpath/src/corelib/global"
[ -f "$QCONFIG_H" ] && chmod +w "$QCONFIG_H"
echo "/* All features enabled while building qmake */" >"$QMAKE_QCONFIG_H"
fi
mv -f "$QMAKE_QCONFIG_H" "$QCONFIG_H"
for conf in "$outpath/include/QtCore/qconfig.h" "$outpath/include/Qt/qconfig.h"; do
[ -e "$conf" ] && rm -rf "$conf"
cp -a "$QCONFIG_H" "$conf"
done
#mkspecs/default is used as a (gasp!) default mkspec so QMAKESPEC needn't be set once configured
rm -rf mkspecs/default
cp -a `echo $XQMAKESPEC | sed "s,^${relpath}/mkspecs/,,"` mkspecs/default
# fix makefiles
for mkfile in GNUmakefile Makefile; do
EXTRA_LFLAGS=
EXTRA_CFLAGS=
in_mkfile="${mkfile}.in"
if [ "$mkfile" = "Makefile" ]; then
# if which qmake >/dev/null 2>&1 && [ -f qmake/qmake.pro ]; then
# (cd qmake && qmake) >/dev/null 2>&1 && continue
# fi
in_mkfile="${mkfile}.unix"
fi
in_mkfile="$relpath/qmake/$in_mkfile"
mkfile="$outpath/qmake/$mkfile"
if [ -f "$mkfile" ]; then
[ "$CFG_DEV" = "yes" ] && "$WHICH" chflags >/dev/null 2>&1 && chflags nouchg "$mkfile"
rm -f "$mkfile"
fi
[ -f "$in_mkfile" ] || continue
echo "########################################################################" > "$mkfile"
echo "## This file was autogenerated by configure, all changes will be lost ##" >> "$mkfile"
echo "########################################################################" >> "$mkfile"
EXTRA_OBJS=
EXTRA_SRCS=
EXTRA_CFLAGS="\$(QMAKE_CFLAGS)"
EXTRA_CXXFLAGS="\$(QMAKE_CXXFLAGS)"
EXTRA_LFLAGS="\$(QMAKE_LFLAGS)"
if [ "$PLATFORM" = "irix-cc" ] || [ "$PLATFORM" = "irix-cc-64" ]; then
EXTRA_LFLAGS="$EXTRA_LFLAGS -lm"
fi
[ -n "$CC" ] && echo "CC = $CC" >> "$mkfile"
[ -n "$CXX" ] && echo "CXX = $CXX" >> "$mkfile"
if [ "$CFG_SILENT" = "yes" ]; then
[ -z "$CC" ] && setBootstrapVariable QMAKE_CC 's,QMAKE_CC.*=,CC=\@,'
[ -z "$CXX" ] && setBootstrapVariable QMAKE_CXX 's,QMAKE_CXX.*=,CXX=\@,'
else
[ -z "$CC" ] && setBootstrapVariable QMAKE_CC 's,QMAKE_CC,CC,'
[ -z "$CXX" ] && setBootstrapVariable QMAKE_CXX 's,QMAKE_CXX,CXX,'
fi
setBootstrapVariable QMAKE_CFLAGS
setBootstrapVariable QMAKE_CXXFLAGS 's,\$\$QMAKE_CFLAGS,\$(QMAKE_CFLAGS),'
setBootstrapVariable QMAKE_LFLAGS
if [ $QT_EDITION = "QT_EDITION_OPENSOURCE" ]; then
EXTRA_CFLAGS="$EXTRA_CFLAGS -DQMAKE_OPENSOURCE_EDITION"
EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS -DQMAKE_OPENSOURCE_EDITION"
fi
if [ "$CFG_RELEASE_QMAKE" = "yes" ]; then
setBootstrapVariable QMAKE_CFLAGS_RELEASE
setBootstrapVariable QMAKE_CXXFLAGS_RELEASE 's,\$\$QMAKE_CFLAGS_RELEASE,\$(QMAKE_CFLAGS_RELEASE),'
EXTRA_CFLAGS="$EXTRA_CFLAGS \$(QMAKE_CFLAGS_RELEASE)"
EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS \$(QMAKE_CXXFLAGS_RELEASE)"
elif [ "$CFG_DEBUG" = "yes" ]; then
setBootstrapVariable QMAKE_CFLAGS_DEBUG
setBootstrapVariable QMAKE_CXXFLAGS_DEBUG 's,\$\$QMAKE_CFLAGS_DEBUG,\$(QMAKE_CFLAGS_DEBUG),'
EXTRA_CFLAGS="$EXTRA_CFLAGS \$(QMAKE_CFLAGS_DEBUG)"
EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS \$(QMAKE_CXXFLAGS_DEBUG)"
fi
if [ '!' -z "$RPATH_FLAGS" ] && [ '!' -z "`getQMakeConf \"$QMAKESPEC\" | grep QMAKE_RPATH | awk '{print $3;}'`" ]; then
setBootstrapVariable QMAKE_RPATH 's,\$\$LITERAL_WHITESPACE, ,'
for rpath in $RPATH_FLAGS; do
EXTRA_LFLAGS="\$(QMAKE_RPATH)\"$rpath\" $EXTRA_LFLAGS"
done
fi
if [ "$PLATFORM_MAC" = "yes" ]; then
echo "export MACOSX_DEPLOYMENT_TARGET = 10.4" >> "$mkfile"
echo "CARBON_LFLAGS =-framework ApplicationServices" >>"$mkfile"
echo "CARBON_CFLAGS =-fconstant-cfstrings" >>"$mkfile"
EXTRA_LFLAGS="$EXTRA_LFLAGS \$(CARBON_LFLAGS)"
EXTRA_CFLAGS="$EXTRA_CFLAGS \$(CARBON_CFLAGS)"
EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS \$(CARBON_CFLAGS)"
EXTRA_OBJS="qsettings_mac.o qcore_mac.o"
EXTRA_SRCS="\"$relpath/src/corelib/io/qsettings_mac.cpp\" \"$relpath/src/corelib/kernel/qcore_mac.cpp\""
if echo "$CFG_MAC_ARCHS" | grep x86 > /dev/null 2>&1; then # matches both x86 and x86_64
X86_CFLAGS="-arch i386"
X86_LFLAGS="-arch i386"
EXTRA_CFLAGS="$X86_CFLAGS $EXTRA_CFLAGS"
EXTRA_CXXFLAGS="$X86_CFLAGS $EXTRA_CXXFLAGS"
EXTRA_LFLAGS="$EXTRA_LFLAGS $X86_LFLAGS"
fi
if echo "$CFG_MAC_ARCHS" | grep ppc > /dev/null 2>&1; then # matches both ppc and ppc64
PPC_CFLAGS="-arch ppc"
PPC_LFLAGS="-arch ppc"
EXTRA_CFLAGS="$PPC_CFLAGS $EXTRA_CFLAGS"
EXTRA_CXXFLAGS="$PPC_CFLAGS $EXTRA_CXXFLAGS"
EXTRA_LFLAGS="$EXTRA_LFLAGS $PPC_LFLAGS"
fi
if [ '!' -z "$CFG_SDK" ]; then
echo "SDK_LFLAGS =-Wl,-syslibroot,$CFG_SDK" >>"$mkfile"
echo "SDK_CFLAGS =-isysroot $CFG_SDK" >>"$mkfile"
EXTRA_CFLAGS="$EXTRA_CFLAGS \$(SDK_CFLAGS)"
EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS \$(SDK_CFLAGS)"
EXTRA_LFLAGS="$EXTRA_LFLAGS \$(SDK_LFLAGS)"
fi
fi
[ "$CFG_EMBEDDED" != "no" ] && EXTRA_CFLAGS="$EXTRA_CFLAGS -DQWS"
if [ '!' -z "$D_FLAGS" ]; then
for DEF in $D_FLAGS; do
EXTRA_CFLAGS="$EXTRA_CFLAGS \"-D${DEF}\""
done
fi
QMAKE_BIN_DIR="$QT_INSTALL_BINS"
[ -z "$QMAKE_BIN_DIR" ] && QMAKE_BIN_DIR="${QT_INSTALL_PREFIX}/bin"
QMAKE_DATA_DIR="$QT_INSTALL_DATA"
[ -z "$QMAKE_DATA_DIR" ] && QMAKE_DATA_DIR="${QT_INSTALL_PREFIX}"
echo >>"$mkfile"
adjrelpath=`echo "$relpath" | sed 's/ /\\\\\\\\ /g'`
adjoutpath=`echo "$outpath" | sed 's/ /\\\\\\\\ /g'`
adjqmakespec=`echo "$QMAKESPEC" | sed 's/ /\\\\\\\\ /g'`
sed -e "s,@SOURCE_PATH@,$adjrelpath,g" -e "s,@BUILD_PATH@,$adjoutpath,g" \
-e "s,@QMAKE_CFLAGS@,$EXTRA_CFLAGS,g" -e "s,@QMAKE_LFLAGS@,$EXTRA_LFLAGS,g" \
-e "s,@QMAKE_CXXFLAGS@,$EXTRA_CXXFLAGS,g" \
-e "s,@QT_INSTALL_BINS@,\$(INSTALL_ROOT)$QMAKE_BIN_DIR,g" \
-e "s,@QT_INSTALL_DATA@,\$(INSTALL_ROOT)$QMAKE_DATA_DIR,g" \
-e "s,@QMAKE_QTOBJS@,$EXTRA_OBJS,g" -e "s,@QMAKE_QTSRCS@,$EXTRA_SRCS,g" \
-e "s,@QMAKESPEC@,$adjqmakespec,g" "$in_mkfile" >>"$mkfile"
if "$WHICH" makedepend >/dev/null 2>&1 && grep 'depend:' "$mkfile" >/dev/null 2>&1; then
(cd "$outpath/qmake" && "$MAKE" -f "$mkfile" depend) >/dev/null 2>&1
sed "s,^.*/\([^/]*.o\):,\1:,g" "$mkfile" >"$mkfile.tmp"
sed "s,$outpath,$adjoutpath,g" "$mkfile.tmp" >"$mkfile"
rm "$mkfile.tmp"
fi
done
QMAKE_BUILD_ERROR=no
(cd "$outpath/qmake"; "$MAKE") || QMAKE_BUILD_ERROR=yes
[ '!' -z "$QCONFIG_H" ] && mv -f "$QCONFIG_H" "$QMAKE_QCONFIG_H" #move qmake's qconfig.h to qconfig.h.qmake
[ '!' -z "$OLD_QCONFIG_H" ] && mv -f "${OLD_QCONFIG_H}.old" "$OLD_QCONFIG_H" #put back qconfig.h
[ "$QMAKE_BUILD_ERROR" = "yes" ] && exit 2
fi # Build qmake
#-------------------------------------------------------------------------------
# tests that need qmake
#-------------------------------------------------------------------------------
# detect availability of float math.h functions
if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/floatmath "floatmath" $L_FLAGS $I_FLAGS $l_FLAGS; then
CFG_USE_FLOATMATH=yes
else
CFG_USE_FLOATMATH=no
fi
# detect mmx support
if [ "${CFG_MMX}" = "auto" ]; then
if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/mmx "mmx" $L_FLAGS $I_FLAGS $l_FLAGS "-mmmx"; then
CFG_MMX=yes
else
CFG_MMX=no
fi
fi
# detect 3dnow support
if [ "${CFG_3DNOW}" = "auto" ]; then
if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/3dnow "3dnow" $L_FLAGS $I_FLAGS $l_FLAGS "-m3dnow"; then
CFG_3DNOW=yes
else
CFG_3DNOW=no
fi
fi
# detect sse support
if [ "${CFG_SSE}" = "auto" ]; then
if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/sse "sse" $L_FLAGS $I_FLAGS $l_FLAGS "-msse"; then
CFG_SSE=yes
else
CFG_SSE=no
fi
fi
# detect sse2 support
if [ "${CFG_SSE2}" = "auto" ]; then
if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/sse2 "sse2" $L_FLAGS $I_FLAGS $l_FLAGS "-msse2"; then
CFG_SSE2=yes
else
CFG_SSE2=no
fi
fi
# check iWMMXt support
if [ "$CFG_IWMMXT" = "yes" ]; then
"$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/iwmmxt "iwmmxt" $L_FLAGS $I_FLAGS $l_FLAGS "-mcpu=iwmmxt"
if [ $? != "0" ]; then
echo "The iWMMXt functionality test failed!"
echo " Please make sure your compiler supports iWMMXt intrinsics!"
exit 1
fi
fi
# detect zlib
if [ "$CFG_ZLIB" = "no" ]; then
# Note: Qt no longer support builds without zlib
# So we force a "no" to be "auto" here.
# If you REALLY really need no zlib support, you can still disable
# it by doing the following:
# add "no-zlib" to mkspecs/qconfig.pri
# #define QT_NO_COMPRESS (probably by adding to src/corelib/global/qconfig.h)
#
# There's no guarantee that Qt will build under those conditions
CFG_ZLIB=auto
ZLIB_FORCED=yes
fi
if [ "$CFG_ZLIB" = "auto" ]; then
if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/zlib "zlib" $L_FLAGS $I_FLAGS $l_FLAGS $MAC_CONFIG_TEST_COMMANDLINE; then
CFG_ZLIB=system
else
CFG_ZLIB=yes
fi
fi
# detect how jpeg should be built
if [ "$CFG_JPEG" = "auto" ]; then
if [ "$CFG_SHARED" = "yes" ]; then
CFG_JPEG=plugin
else
CFG_JPEG=yes
fi
fi
# detect jpeg
if [ "$CFG_LIBJPEG" = "auto" ]; then
if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/libjpeg "libjpeg" $L_FLAGS $I_FLAGS $l_FLAGS $MAC_CONFIG_TEST_COMMANDLINE; then
CFG_LIBJPEG=system
else
CFG_LIBJPEG=qt
fi
fi
# detect how gif should be built
if [ "$CFG_GIF" = "auto" ]; then
if [ "$CFG_SHARED" = "yes" ]; then
CFG_GIF=plugin
else
CFG_GIF=yes
fi
fi
# detect how tiff should be built
if [ "$CFG_TIFF" = "auto" ]; then
if [ "$CFG_SHARED" = "yes" ]; then
CFG_TIFF=plugin
else
CFG_TIFF=yes
fi
fi
# detect tiff
if [ "$CFG_LIBTIFF" = "auto" ]; then
if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/libtiff "libtiff" $L_FLAGS $I_FLAGS $l_FLAGS $MAC_CONFIG_TEST_COMMANDLINE; then
CFG_LIBTIFF=system
else
CFG_LIBTIFF=qt
fi
fi
# detect how mng should be built
if [ "$CFG_MNG" = "auto" ]; then
if [ "$CFG_SHARED" = "yes" ]; then
CFG_MNG=plugin
else
CFG_MNG=yes
fi
fi
# detect mng
if [ "$CFG_LIBMNG" = "auto" ]; then
if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/libmng "libmng" $L_FLAGS $I_FLAGS $l_FLAGS $MAC_CONFIG_TEST_COMMANDLINE; then
CFG_LIBMNG=system
else
CFG_LIBMNG=qt
fi
fi
# detect png
if [ "$CFG_LIBPNG" = "auto" ]; then
if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/libpng "libpng" $L_FLAGS $I_FLAGS $l_FLAGS $MAC_CONFIG_TEST_COMMANDLINE; then
CFG_LIBPNG=system
else
CFG_LIBPNG=qt
fi
fi
# detect accessibility
if [ "$CFG_ACCESSIBILITY" = "auto" ]; then
CFG_ACCESSIBILITY=yes
fi
# auto-detect SQL-modules support
for _SQLDR in $CFG_SQL_AVAILABLE; do
case $_SQLDR in
mysql)
if [ "$CFG_SQL_mysql" != "no" ]; then
[ -z "$CFG_MYSQL_CONFIG" ] && CFG_MYSQL_CONFIG=`"$WHICH" mysql_config`
if [ -x "$CFG_MYSQL_CONFIG" ]; then
QT_CFLAGS_MYSQL=`$CFG_MYSQL_CONFIG --include 2>/dev/null`
QT_LFLAGS_MYSQL_R=`$CFG_MYSQL_CONFIG --libs_r 2>/dev/null`
QT_LFLAGS_MYSQL=`$CFG_MYSQL_CONFIG --libs 2>/dev/null`
QT_MYSQL_VERSION=`$CFG_MYSQL_CONFIG --version 2>/dev/null`
QT_MYSQL_VERSION_MAJOR=`echo $QT_MYSQL_VERSION | cut -d . -f 1`
fi
if [ -n "$QT_MYSQL_VERSION" ] && [ "$QT_MYSQL_VERSION_MAJOR" -lt 4 ]; then
if [ "$CFG_SQL_mysql" != "auto" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
echo "This version of MySql is not supported ($QT_MYSQL_VERSION)."
echo " You need MySql 4 or higher."
echo " If you believe this message is in error you may use the continue"
echo " switch (-continue) to $0 to continue."
exit 101
else
CFG_SQL_mysql="no"
QT_LFLAGS_MYSQL=""
QT_LFLAGS_MYSQL_R=""
QT_CFLAGS_MYSQL=""
fi
else
if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/mysql_r "MySQL (thread-safe)" $QT_LFLAGS_MYSQL_R $L_FLAGS $QT_CFLAGS_MYSQL $I_FLAGS $l_FLAGS $MAC_CONFIG_TEST_COMMANDLINE; then
QMakeVar add CONFIG use_libmysqlclient_r
if [ "$CFG_SQL_mysql" = "auto" ]; then
CFG_SQL_mysql=plugin
fi
QT_LFLAGS_MYSQL="$QT_LFLAGS_MYSQL_R"
elif "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/mysql "MySQL (thread-unsafe)" $QT_LFLAGS_MYSQL $L_FLAGS $QT_CFLAGS_MYSQL $I_FLAGS $l_FLAGS $MAC_CONFIG_TEST_COMMANDLINE; then
if [ "$CFG_SQL_mysql" = "auto" ]; then
CFG_SQL_mysql=plugin
fi
else
if [ "$CFG_SQL_mysql" != "auto" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
echo "MySQL support cannot be enabled due to functionality tests!"
echo " Turn on verbose messaging (-v) to $0 to see the final report."
echo " If you believe this message is in error you may use the continue"
echo " switch (-continue) to $0 to continue."
exit 101
else
CFG_SQL_mysql=no
QT_LFLAGS_MYSQL=""
QT_LFLAGS_MYSQL_R=""
QT_CFLAGS_MYSQL=""
fi
fi
fi
fi
;;
psql)
if [ "$CFG_SQL_psql" != "no" ]; then
if "$WHICH" pg_config >/dev/null 2>&1; then
QT_CFLAGS_PSQL=`pg_config --includedir 2>/dev/null`
QT_LFLAGS_PSQL=`pg_config --libdir 2>/dev/null`
fi
[ -z "$QT_CFLAGS_PSQL" ] || QT_CFLAGS_PSQL="-I$QT_CFLAGS_PSQL"
[ -z "$QT_LFLAGS_PSQL" ] || QT_LFLAGS_PSQL="-L$QT_LFLAGS_PSQL"
if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/psql "PostgreSQL" $QT_LFLAGS_PSQL $L_FLAGS $QT_CFLAGS_PSQL $I_FLAGS $l_FLAGS $MAC_CONFIG_TEST_COMMANDLINE; then
if [ "$CFG_SQL_psql" = "auto" ]; then
CFG_SQL_psql=plugin
fi
else
if [ "$CFG_SQL_psql" != "auto" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
echo "PostgreSQL support cannot be enabled due to functionality tests!"
echo " Turn on verbose messaging (-v) to $0 to see the final report."
echo " If you believe this message is in error you may use the continue"
echo " switch (-continue) to $0 to continue."
exit 101
else
CFG_SQL_psql=no
QT_CFLAGS_PSQL=""
QT_LFLAGS_PSQL=""
fi
fi
fi
;;
odbc)
if [ "$CFG_SQL_odbc" != "no" ]; then
if [ "$PLATFORM_MAC" != "yes" ] && "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/odbc "ODBC" $L_FLAGS $I_FLAGS $l_FLAGS $MAC_CONFIG_TEST_COMMANDLINE; then
if [ "$CFG_SQL_odbc" = "auto" ]; then
CFG_SQL_odbc=plugin
fi
else
if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/iodbc "iODBC" $L_FLAGS $I_FLAGS $l_FLAGS $MAC_CONFIG_TEST_COMMANDLINE; then
QT_LFLAGS_ODBC="-liodbc"
if [ "$CFG_SQL_odbc" = "auto" ]; then
CFG_SQL_odbc=plugin
fi
else
if [ "$CFG_SQL_odbc" != "auto" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
echo "ODBC support cannot be enabled due to functionality tests!"
echo " Turn on verbose messaging (-v) to $0 to see the final report."
echo " If you believe this message is in error you may use the continue"
echo " switch (-continue) to $0 to continue."
exit 101
else
CFG_SQL_odbc=no
fi
fi
fi
fi
;;
oci)
if [ "$CFG_SQL_oci" != "no" ]; then
if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/oci "OCI" $L_FLAGS $I_FLAGS $l_FLAGS $MAC_CONFIG_TEST_COMMANDLINE; then
if [ "$CFG_SQL_oci" = "auto" ]; then
CFG_SQL_oci=plugin
fi
else
if [ "$CFG_SQL_oci" != "auto" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
echo "Oracle (OCI) support cannot be enabled due to functionality tests!"
echo " Turn on verbose messaging (-v) to $0 to see the final report."
echo " If you believe this message is in error you may use the continue"
echo " switch (-continue) to $0 to continue."
exit 101
else
CFG_SQL_oci=no
fi
fi
fi
;;
tds)
if [ "$CFG_SQL_tds" != "no" ]; then
if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/tds "TDS" $L_FLAGS $I_FLAGS $l_FLAGS $MAC_CONFIG_TEST_COMMANDLINE; then
if [ "$CFG_SQL_tds" = "auto" ]; then
CFG_SQL_tds=plugin
fi
else
if [ "$CFG_SQL_tds" != "auto" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
echo "TDS support cannot be enabled due to functionality tests!"
echo " Turn on verbose messaging (-v) to $0 to see the final report."
echo " If you believe this message is in error you may use the continue"
echo " switch (-continue) to $0 to continue."
exit 101
else
CFG_SQL_tds=no
fi
fi
fi
;;
db2)
if [ "$CFG_SQL_db2" != "no" ]; then
if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/db2 "DB2" $L_FLAGS $I_FLAGS $l_FLAGS $MAC_CONFIG_TEST_COMMANDLINE; then
if [ "$CFG_SQL_db2" = "auto" ]; then
CFG_SQL_db2=plugin
fi
else
if [ "$CFG_SQL_db2" != "auto" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
echo "ODBC support cannot be enabled due to functionality tests!"
echo " Turn on verbose messaging (-v) to $0 to see the final report."
echo " If you believe this message is in error you may use the continue"
echo " switch (-continue) to $0 to continue."
exit 101
else
CFG_SQL_db2=no
fi
fi
fi
;;
ibase)
if [ "$CFG_SQL_ibase" != "no" ]; then
if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/ibase "InterBase" $L_FLAGS $I_FLAGS $l_FLAGS $MAC_CONFIG_TEST_COMMANDLINE; then
if [ "$CFG_SQL_ibase" = "auto" ]; then
CFG_SQL_ibase=plugin
fi
else
if [ "$CFG_SQL_ibase" != "auto" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
echo "InterBase support cannot be enabled due to functionality tests!"
echo " Turn on verbose messaging (-v) to $0 to see the final report."
echo " If you believe this message is in error you may use the continue"
echo " switch (-continue) to $0 to continue."
exit 101
else
CFG_SQL_ibase=no
fi
fi
fi
;;
sqlite2)
if [ "$CFG_SQL_sqlite2" != "no" ]; then
if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/sqlite2 "SQLite2" $L_FLAGS $I_FLAGS $l_FLAGS $MAC_CONFIG_TEST_COMMANDLINE; then
if [ "$CFG_SQL_sqlite2" = "auto" ]; then
CFG_SQL_sqlite2=plugin
fi
else
if [ "$CFG_SQL_sqlite2" != "auto" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
echo "SQLite2 support cannot be enabled due to functionality tests!"
echo " Turn on verbose messaging (-v) to $0 to see the final report."
echo " If you believe this message is in error you may use the continue"
echo " switch (-continue) to $0 to continue."
exit 101
else
CFG_SQL_sqlite2=no
fi
fi
fi
;;
sqlite)
if [ "$CFG_SQL_sqlite" != "no" ]; then
SQLITE_AUTODETECT_FAILED="no"
if [ "$CFG_SQLITE" = "system" ]; then
if [ -n "$PKG_CONFIG" ]; then
QT_CFLAGS_SQLITE=`$PKG_CONFIG --cflags sqlite3 2>/dev/null`
QT_LFLAGS_SQLITE=`$PKG_CONFIG --libs sqlite3 2>/dev/null`
fi
if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/sqlite "SQLite" $QT_LFLAGS_SQLITE $L_FLAGS $QT_CFLAGS_SQLITE $I_FLAGS $l_FLAGS $MAC_CONFIG_TEST_COMMANDLINE; then
if [ "$CFG_SQL_sqlite" = "auto" ]; then
CFG_SQL_sqlite=plugin
fi
QMAKE_CONFIG="$QMAKE_CONFIG system-sqlite"
else
SQLITE_AUTODETECT_FAILED="yes"
CFG_SQL_sqlite=no
fi
elif [ -f "$relpath/src/3rdparty/sqlite/sqlite3.h" ]; then
if [ "$CFG_SQL_sqlite" = "auto" ]; then
CFG_SQL_sqlite=plugin
fi
else
SQLITE_AUTODETECT_FAILED="yes"
CFG_SQL_sqlite=no
fi
if [ "$SQLITE_AUTODETECT_FAILED" = "yes" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
echo "SQLite support cannot be enabled due to functionality tests!"
echo " Turn on verbose messaging (-v) to $0 to see the final report."
echo " If you believe this message is in error you may use the continue"
echo " switch (-continue) to $0 to continue."
exit 101
fi
fi
;;
*)
if [ "$OPT_VERBOSE" = "yes" ]; then
echo "unknown SQL driver: $_SQLDR"
fi
;;
esac
done
#for the symbian we need add sql_lite support
QMAKE_CONFIG="$QMAKE_CONFIG system-sqlite"
QMAKE_CONFIG="$QMAKE_CONFIG minimal-config small-config medium-config large-config full-config"
if [ "$PLATFORM_SYMBIAN" = "yes" ]; then
if [ "$CFG_DEFFILES" = "yes" ]; then
QMakeVar add CONFIG def_files
else
QMakeVar add CONFIG def_files_disabled
fi
fi
# auto-detect NIS support
if [ "$CFG_NIS" != "no" ]; then
if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/nis "NIS" $L_FLAGS $I_FLAGS $l_FLAGS $MAC_CONFIG_TEST_COMMANDLINE; then
CFG_NIS=yes
else
if [ "$CFG_NIS" = "yes" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
echo "NIS support cannot be enabled due to functionality tests!"
echo " Turn on verbose messaging (-v) to $0 to see the final report."
echo " If you believe this message is in error you may use the continue"
echo " switch (-continue) to $0 to continue."
exit 101
else
CFG_NIS=no
fi
fi
fi
# auto-detect libdbus-1 support
if [ "$CFG_DBUS" != "no" ]; then
if [ -n "$PKG_CONFIG" ] && $PKG_CONFIG --atleast-version="$MIN_DBUS_1_VERSION" dbus-1 2>/dev/null; then
QT_CFLAGS_DBUS=`$PKG_CONFIG --cflags dbus-1 2>/dev/null`
QT_LIBS_DBUS=`$PKG_CONFIG --libs dbus-1 2>/dev/null`
fi
if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/dbus "D-Bus" $L_FLAGS $I_FLAGS $l_FLAGS $QT_CFLAGS_DBUS $QT_LIBS_DBUS $MAC_CONFIG_TEST_COMMANDLINE; then
[ "$CFG_DBUS" = "auto" ] && CFG_DBUS=yes
QMakeVar set QT_CFLAGS_DBUS "$QT_CFLAGS_DBUS"
QMakeVar set QT_LIBS_DBUS "$QT_LIBS_DBUS"
else
if [ "$CFG_DBUS" = "auto" ]; then
CFG_DBUS=no
elif [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
# CFG_DBUS is "yes" or "linked" here
echo "The QtDBus module cannot be enabled because libdbus-1 version $MIN_DBUS_1_VERSION was not found."
echo " Turn on verbose messaging (-v) to $0 to see the final report."
echo " If you believe this message is in error you may use the continue"
echo " switch (-continue) to $0 to continue."
exit 101
fi
fi
fi
# Generate a CRC of the namespace for using in constants for the Carbon port.
# This should mean that you really *can* load two Qt's and have our custom
# Carbon events work.
if [ "$PLATFORM_MAC" = "yes" -a ! -z "$QT_NAMESPACE" ]; then
QT_NAMESPACE_MAC_CRC=`"$mactests/crc.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/mac/crc $QT_NAMESPACE $L_FLAGS $I_FLAGS $l_FLAGS`
fi
if [ "$XPLATFORM" = "symbian-sbsv2" ]; then
# detect EGL support
if [ "$CFG_OPENVG" = "yes" ]; then
CFG_EGL=yes
fi
fi
if [ "$PLATFORM_X11" = "yes" -o "$PLATFORM_QWS" = "yes" ]; then
# auto-detect Glib support
if [ "$CFG_GLIB" != "no" ]; then
if [ -n "$PKG_CONFIG" ]; then
QT_CFLAGS_GLIB=`$PKG_CONFIG --cflags glib-2.0 gthread-2.0 2>/dev/null`
QT_LIBS_GLIB=`$PKG_CONFIG --libs glib-2.0 gthread-2.0 2>/dev/null`
fi
if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/glib "Glib" $L_FLAGS $I_FLAGS $l_FLAGS $QT_CFLAGS_GLIB $QT_LIBS_GLIB $X11TESTS_FLAGS ; then
CFG_GLIB=yes
QMakeVar set QT_CFLAGS_GLIB "$QT_CFLAGS_GLIB"
QMakeVar set QT_LIBS_GLIB "$QT_LIBS_GLIB"
else
if [ "$CFG_GLIB" = "yes" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
echo "Glib support cannot be enabled due to functionality tests!"
echo " Turn on verbose messaging (-v) to $0 to see the final report."
echo " If you believe this message is in error you may use the continue"
echo " switch (-continue) to $0 to continue."
exit 101
else
CFG_GLIB=no
fi
fi
fi
if [ "$CFG_PHONON" != "no" ]; then
if [ "$CFG_PHONON_BACKEND" != "no" ]; then
if [ "$CFG_GLIB" = "yes" -a "$CFG_GSTREAMER" != "no" ]; then
if [ -n "$PKG_CONFIG" ]; then
QT_CFLAGS_GSTREAMER=`$PKG_CONFIG --cflags gstreamer-0.10 gstreamer-plugins-base-0.10 2>/dev/null`
QT_LIBS_GSTREAMER=`$PKG_CONFIG --libs gstreamer-0.10 gstreamer-plugins-base-0.10 2>/dev/null`
fi
if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/gstreamer "GStreamer" $L_FLAGS $I_FLAGS $l_FLAGS $QT_CFLAGS_GSTREAMER $QT_LIBS_GSTREAMER $X11TESTS_FLAGS; then
CFG_GSTREAMER=yes
QMakeVar set QT_CFLAGS_GSTREAMER "$QT_CFLAGS_GSTREAMER"
QMakeVar set QT_LIBS_GSTREAMER "$QT_LIBS_GSTREAMER"
else
if [ "$CFG_GSTREAMER" = "yes" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
echo "Gstreamer support cannot be enabled due to functionality tests!"
echo " Turn on verbose messaging (-v) to $0 to see the final report."
echo " If you believe this message is in error you may use the continue"
echo " switch (-continue) to $0 to continue."
exit 101
else
CFG_GSTREAMER=no
fi
fi
elif [ "$CFG_GLIB" = "no" ]; then
CFG_GSTREAMER=no
fi
if [ "$CFG_GSTREAMER" = "yes" ]; then
CFG_PHONON=yes
else
if [ "$CFG_PHONON" = "yes" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
echo "Phonon support cannot be enabled due to functionality tests!"
echo " Turn on verbose messaging (-v) to $0 to see the final report."
echo " If you believe this message is in error you may use the continue"
echo " switch (-continue) to $0 to continue."
exit 101
else
CFG_PHONON=no
fi
fi
else
CFG_PHONON=yes
fi
fi
fi # X11/QWS
# x11
if [ "$PLATFORM_X11" = "yes" ]; then
x11tests="$relpath/config.tests/x11"
X11TESTS_FLAGS=
# work around broken X11 headers when using GCC 2.95 or later
NOTYPE=no
"$x11tests/notype.test" "$XQMAKESPEC" $OPT_VERBOSE "$relpath" "$outpath" && NOTYPE=yes
if [ $NOTYPE = "yes" ]; then
QMakeVar add QMAKE_CXXFLAGS -fpermissive
X11TESTS_FLAGS="$X11TESTS_FLAGS -fpermissive"
fi
# Check we actually have X11 :-)
"$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/x11/xlib "XLib" $L_FLAGS $I_FLAGS $l_FLAGS $X11TESTS_FLAGS
if [ $? != "0" ]; then
echo "Basic XLib functionality test failed!"
echo " You might need to modify the include and library search paths by editing"
echo " QMAKE_INCDIR_X11 and QMAKE_LIBDIR_X11 in ${XQMAKESPEC}."
exit 1
fi
# auto-detect OpenGL support (es1 = OpenGL ES 1.x Common, es1cl = ES 1.x common lite, es2 = OpenGL ES 2.x)
if [ "$CFG_OPENGL" = "auto" ] || [ "$CFG_OPENGL" = "yes" ]; then
if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/x11/opengl "OpenGL" $L_FLAGS $I_FLAGS $l_FLAGS $X11TESTS_FLAGS; then
CFG_OPENGL=desktop
elif "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/opengles2 "OpenGL ES 2.x" $L_FLAGS $I_FLAGS $l_FLAGS; then
CFG_OPENGL=es2
elif "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/opengles1 "OpenGL ES 1.x" $L_FLAGS $I_FLAGS $l_FLAGS; then
CFG_OPENGL=es1
elif "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/opengles1cl "OpenGL ES 1.x Lite" $L_FLAGS $I_FLAGS $l_FLAGS; then
CFG_OPENGL=es1cl
else
if [ "$CFG_OPENGL" = "yes" ]; then
echo "All the OpenGL functionality tests failed!"
echo " You might need to modify the include and library search paths by editing"
echo " QMAKE_INCDIR_OPENGL, QMAKE_LIBDIR_OPENGL and QMAKE_LIBS_OPENGL in"
echo " ${XQMAKESPEC}."
exit 1
fi
CFG_OPENGL=no
fi
case "$PLATFORM" in
hpux*)
# HP-UX have buggy glx headers; check if we really need to define the GLXFBConfig struct.
if [ "$CFG_OPENGL" = "desktop" ]; then
"$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/x11/glxfbconfig "OpenGL" $L_FLAGS $I_FLAGS $l_FLAGS $X11TESTS_FLAGS
if [ $? != "0" ]; then
QMakeVar add DEFINES QT_DEFINE_GLXFBCONFIG_STRUCT
fi
fi
;;
*)
;;
esac
elif [ "$CFG_OPENGL" = "es1cl" ]; then
# OpenGL ES 1.x common lite
"$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/opengles1cl "OpenGL ES 1.x Lite" $L_FLAGS $I_FLAGS $l_FLAGS
if [ $? != "0" ]; then
echo "The OpenGL ES 1.x Common Lite Profile functionality test failed!"
echo " You might need to modify the include and library search paths by editing"
echo " QMAKE_INCDIR_OPENGL, QMAKE_LIBDIR_OPENGL and QMAKE_LIBS_OPENGL in"
echo " ${XQMAKESPEC}."
exit 1
fi
elif [ "$CFG_OPENGL" = "es1" ]; then
# OpenGL ES 1.x
"$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/opengles1 "OpenGL ES 1.x" $L_FLAGS $I_FLAGS $l_FLAGS
if [ $? != "0" ]; then
echo "The OpenGL ES 1.x functionality test failed!"
echo " You might need to modify the include and library search paths by editing"
echo " QMAKE_INCDIR_OPENGL, QMAKE_LIBDIR_OPENGL and QMAKE_LIBS_OPENGL in"
echo " ${XQMAKESPEC}."
exit 1
fi
elif [ "$CFG_OPENGL" = "es2" ]; then
#OpenGL ES 2.x
"$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/opengles2 "OpenGL ES 2.x" $L_FLAGS $I_FLAGS $l_FLAGS
if [ $? != "0" ]; then
echo "The OpenGL ES 2.0 functionality test failed!"
echo " You might need to modify the include and library search paths by editing"
echo " QMAKE_INCDIR_OPENGL, QMAKE_LIBDIR_OPENGL and QMAKE_LIBS_OPENGL in"
echo " ${XQMAKESPEC}."
exit 1
fi
elif [ "$CFG_OPENGL" = "desktop" ]; then
# Desktop OpenGL support
"$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/x11/opengl "OpenGL" $L_FLAGS $I_FLAGS $l_FLAGS $X11TESTS_FLAGS
if [ $? != "0" ]; then
echo "The OpenGL functionality test failed!"
echo " You might need to modify the include and library search paths by editing"
echo " QMAKE_INCDIR_OPENGL, QMAKE_LIBDIR_OPENGL and QMAKE_LIBS_OPENGL in"
echo " ${XQMAKESPEC}."
exit 1
fi
case "$PLATFORM" in
hpux*)
# HP-UX have buggy glx headers; check if we really need to define the GLXFBConfig struct.
"$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/x11/glxfbconfig "OpenGL" $L_FLAGS $I_FLAGS $l_FLAGS $X11TESTS_FLAGS
if [ $? != "0" ]; then
QMakeVar add DEFINES QT_DEFINE_GLXFBCONFIG_STRUCT
fi
;;
*)
;;
esac
fi
# if opengl is disabled and the user specified graphicssystem gl, disable it...
if [ "$CFG_GRAPHICS_SYSTEM" = "opengl" ] && [ "$CFG_OPENGL" = "no" ]; then
echo "OpenGL Graphics System is disabled due to missing OpenGL support..."
CFG_GRAPHICS_SYSTEM=default
fi
# auto-detect Xcursor support
if [ "$CFG_XCURSOR" != "no" ]; then
if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/x11/xcursor "Xcursor" $L_FLAGS $I_FLAGS $l_FLAGS $X11TESTS_FLAGS; then
if [ "$CFG_XCURSOR" != "runtime" ]; then
CFG_XCURSOR=yes;
fi
else
if [ "$CFG_XCURSOR" = "yes" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
echo "Xcursor support cannot be enabled due to functionality tests!"
echo " Turn on verbose messaging (-v) to $0 to see the final report."
echo " If you believe this message is in error you may use the continue"
echo " switch (-continue) to $0 to continue."
exit 101
else
CFG_XCURSOR=no
fi
fi
fi
# auto-detect Xfixes support
if [ "$CFG_XFIXES" != "no" ]; then
if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/x11/xfixes "Xfixes" $L_FLAGS $I_FLAGS $X11TESTS_FLAGS; then
if [ "$CFG_XFIXES" != "runtime" ]; then
CFG_XFIXES=yes;
fi
else
if [ "$CFG_XFIXES" = "yes" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
echo "Xfixes support cannot be enabled due to functionality tests!"
echo " Turn on verbose messaging (-v) to $0 to see the final report."
echo " If you believe this message is in error you may use the continue"
echo " switch (-continue) to $0 to continue."
exit 101
else
CFG_XFIXES=no
fi
fi
fi
# auto-detect Xrandr support (resize and rotate extension)
if [ "$CFG_XRANDR" != "no" ]; then
if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/x11/xrandr "Xrandr" $L_FLAGS $I_FLAGS $l_FLAGS $X11TESTS_FLAGS; then
if [ "$CFG_XRANDR" != "runtime" ]; then
CFG_XRANDR=yes
fi
else
if [ "$CFG_XRANDR" = "yes" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
echo "Xrandr support cannot be enabled due to functionality tests!"
echo " Turn on verbose messaging (-v) to $0 to see the final report."
echo " If you believe this message is in error you may use the continue"
echo " switch (-continue) to $0 to continue."
exit 101
else
CFG_XRANDR=no
fi
fi
fi
# auto-detect Xrender support
if [ "$CFG_XRENDER" != "no" ]; then
if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/x11/xrender "Xrender" $L_FLAGS $I_FLAGS $l_FLAGS $X11TESTS_FLAGS; then
CFG_XRENDER=yes
else
if [ "$CFG_XRENDER" = "yes" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
echo "Xrender support cannot be enabled due to functionality tests!"
echo " Turn on verbose messaging (-v) to $0 to see the final report."
echo " If you believe this message is in error you may use the continue"
echo " switch (-continue) to $0 to continue."
exit 101
else
CFG_XRENDER=no
fi
fi
fi
# auto-detect MIT-SHM support
if [ "$CFG_MITSHM" != "no" ]; then
if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/x11/mitshm "mitshm" $L_FLAGS $I_FLAGS $l_FLAGS $X11TESTS_FLAGS; then
CFG_MITSHM=yes
else
if [ "$CFG_MITSHM" = "yes" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
echo "MITSHM support cannot be enabled due to functionality tests!"
echo " Turn on verbose messaging (-v) to $0 to see the final report."
echo " If you believe this message is in error you may use the continue"
echo " switch (-continue) to $0 to continue."
exit 101
else
CFG_MITSHM=no
fi
fi
fi
# auto-detect FontConfig support
if [ "$CFG_FONTCONFIG" != "no" ]; then
if [ -n "$PKG_CONFIG" ] && $PKG_CONFIG --exists fontconfig --exists freetype2 2>/dev/null; then
QT_CFLAGS_FONTCONFIG=`$PKG_CONFIG --cflags fontconfig --cflags freetype2 2>/dev/null`
QT_LIBS_FONTCONFIG=`$PKG_CONFIG --libs fontconfig --libs freetype2 2>/dev/null`
else
QT_CFLAGS_FONTCONFIG=
QT_LIBS_FONTCONFIG="-lfreetype -lfontconfig"
fi
if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/x11/fontconfig "FontConfig" $L_FLAGS $I_FLAGS $l_FLAGS $X11TESTS_FLAGS $QT_CFLAGS_FONTCONFIG $QT_LIBS_FONTCONFIG; then
CFG_FONTCONFIG=yes
QMakeVar set QMAKE_CFLAGS_X11 "$QT_CFLAGS_FONTCONFIG \$\$QMAKE_CFLAGS_X11"
QMakeVar set QMAKE_LIBS_X11 "$QT_LIBS_FONTCONFIG \$\$QMAKE_LIBS_X11"
CFG_LIBFREETYPE=system
else
if [ "$CFG_FONTCONFIG" = "yes" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
echo "FontConfig support cannot be enabled due to functionality tests!"
echo " Turn on verbose messaging (-v) to $0 to see the final report."
echo " If you believe this message is in error you may use the continue"
echo " switch (-continue) to $0 to continue."
exit 101
else
CFG_FONTCONFIG=no
fi
fi
fi
# auto-detect Session Management support
if [ "$CFG_SM" = "auto" ]; then
if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/x11/sm "Session Management" $L_FLAGS $I_FLAGS $l_FLAGS $X11TESTS_FLAGS; then
CFG_SM=yes
else
if [ "$CFG_SM" = "yes" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
echo "Session Management support cannot be enabled due to functionality tests!"
echo " Turn on verbose messaging (-v) to $0 to see the final report."
echo " If you believe this message is in error you may use the continue"
echo " switch (-continue) to $0 to continue."
exit 101
else
CFG_SM=no
fi
fi
fi
# auto-detect SHAPE support
if [ "$CFG_XSHAPE" != "no" ]; then
if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/x11/xshape "XShape" $L_FLAGS $I_FLAGS $l_FLAGS $X11TESTS_FLAGS; then
CFG_XSHAPE=yes
else
if [ "$CFG_XSHAPE" = "yes" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
echo "XShape support cannot be enabled due to functionality tests!"
echo " Turn on verbose messaging (-v) to $0 to see the final report."
echo " If you believe this message is in error you may use the continue"
echo " switch (-continue) to $0 to continue."
exit 101
else
CFG_XSHAPE=no
fi
fi
fi
# auto-detect XSync support
if [ "$CFG_XSYNC" != "no" ]; then
if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/x11/xsync "XSync" $L_FLAGS $I_FLAGS $l_FLAGS $X11TESTS_FLAGS; then
CFG_XSYNC=yes
else
if [ "$CFG_XSYNC" = "yes" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
echo "XSync support cannot be enabled due to functionality tests!"
echo " Turn on verbose messaging (-v) to $0 to see the final report."
echo " If you believe this message is in error you may use the continue"
echo " switch (-continue) to $0 to continue."
exit 101
else
CFG_XSYNC=no
fi
fi
fi
# auto-detect Xinerama support
if [ "$CFG_XINERAMA" != "no" ]; then
if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/x11/xinerama "Xinerama" $L_FLAGS $I_FLAGS $l_FLAGS $X11TESTS_FLAGS; then
if [ "$CFG_XINERAMA" != "runtime" ]; then
CFG_XINERAMA=yes
fi
else
if [ "$CFG_XINERAMA" = "yes" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
echo "Xinerama support cannot be enabled due to functionality tests!"
echo " Turn on verbose messaging (-v) to $0 to see the final report."
echo " If you believe this message is in error you may use the continue"
echo " switch (-continue) to $0 to continue."
exit 101
else
CFG_XINERAMA=no
fi
fi
fi
# auto-detect Xinput support
if [ "$CFG_XINPUT" != "no" ]; then
if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/x11/xinput "XInput" $L_FLAGS $I_FLAGS $l_FLAGS $X11TESTS_FLAGS; then
if [ "$CFG_XINPUT" != "runtime" ]; then
CFG_XINPUT=yes
fi
else
if [ "$CFG_XINPUT" = "yes" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
echo "Tablet and Xinput support cannot be enabled due to functionality tests!"
echo " Turn on verbose messaging (-v) to $0 to see the final report."
echo " If you believe this message is in error you may use the continue"
echo " switch (-continue) to $0 to continue."
exit 101
else
CFG_XINPUT=no
fi
fi
fi
# auto-detect XKB support
if [ "$CFG_XKB" != "no" ]; then
if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/x11/xkb "XKB" $L_FLAGS $I_FLAGS $l_FLAGS $X11TESTS_FLAGS; then
CFG_XKB=yes
else
if [ "$CFG_XKB" = "yes" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
echo "XKB support cannot be enabled due to functionality tests!"
echo " Turn on verbose messaging (-v) to $0 to see the final report."
echo " If you believe this message is in error you may use the continue"
echo " switch (-continue) to $0 to continue."
exit 101
else
CFG_XKB=no
fi
fi
fi
if [ "$CFG_GLIB" = "yes" -a "$CFG_QGTKSTYLE" != "no" ]; then
if [ -n "$PKG_CONFIG" ]; then
QT_CFLAGS_QGTKSTYLE=`$PKG_CONFIG --cflags gtk+-2.0 ">=" 2.10 atk 2>/dev/null`
QT_LIBS_QGTKSTYLE=`$PKG_CONFIG --libs gobject-2.0 2>/dev/null`
fi
if [ -n "$QT_CFLAGS_QGTKSTYLE" ] ; then
CFG_QGTKSTYLE=yes
QMakeVar set QT_CFLAGS_QGTKSTYLE "$QT_CFLAGS_QGTKSTYLE"
QMakeVar set QT_LIBS_QGTKSTYLE "$QT_LIBS_QGTKSTYLE"
else
if [ "$CFG_QGTKSTYLE" = "yes" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
echo "Gtk theme support cannot be enabled due to functionality tests!"
echo " Turn on verbose messaging (-v) to $0 to see the final report."
echo " If you believe this message is in error you may use the continue"
echo " switch (-continue) to $0 to continue."
exit 101
else
CFG_QGTKSTYLE=no
fi
fi
elif [ "$CFG_GLIB" = "no" ]; then
CFG_QGTKSTYLE=no
fi
fi # X11
if [ "$PLATFORM_MAC" = "yes" ]; then
if [ "$CFG_PHONON" != "no" ]; then
# Always enable Phonon (unless it was explicitly disabled)
CFG_PHONON=yes
fi
fi
# QWS
if [ "$PLATFORM_QWS" = "yes" ]; then
# auto-detect OpenGL support (es1 = OpenGL ES 1.x Common, es1cl = ES 1.x common lite, es2 = OpenGL ES 2.x)
if [ "$CFG_OPENGL" = "yes" ]; then
if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/opengles2 "OpenGL ES 2.x" $L_FLAGS $I_FLAGS $l_FLAGS; then
CFG_OPENGL=es2
elif "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/opengles1 "OpenGL ES 1.x" $L_FLAGS $I_FLAGS $l_FLAGS; then
CFG_OPENGL=es1
elif "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/opengles1cl "OpenGL ES 1.x Lite" $L_FLAGS $I_FLAGS $l_FLAGS; then
CFG_OPENGL=es1cl
else
echo "All the OpenGL ES functionality tests failed!"
echo " You might need to modify the include and library search paths by editing"
echo " QMAKE_INCDIR_OPENGL, QMAKE_LIBDIR_OPENGL and QMAKE_LIBS_OPENGL in"
echo " ${XQMAKESPEC}."
exit 1
fi
elif [ "$CFG_OPENGL" = "es1" ]; then
# OpenGL ES 1.x
"$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/opengles1 "OpenGL ES 1.x" $L_FLAGS $I_FLAGS $l_FLAGS
if [ $? != "0" ]; then
echo "The OpenGL ES 1.x functionality test failed!"
echo " You might need to modify the include and library search paths by editing"
echo " QMAKE_INCDIR_OPENGL, QMAKE_LIBDIR_OPENGL and QMAKE_LIBS_OPENGL in"
echo " ${XQMAKESPEC}."
exit 1
fi
elif [ "$CFG_OPENGL" = "es2" ]; then
#OpenGL ES 2.x
"$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/opengles2 "OpenGL ES 2.x" $L_FLAGS $I_FLAGS $l_FLAGS
if [ $? != "0" ]; then
echo "The OpenGL ES 2.0 functionality test failed!"
echo " You might need to modify the include and library search paths by editing"
echo " QMAKE_INCDIR_OPENGL, QMAKE_LIBDIR_OPENGL and QMAKE_LIBS_OPENGL in"
echo " ${XQMAKESPEC}."
exit 1
fi
elif [ "$CFG_OPENGL" = "desktop" ]; then
# Desktop OpenGL support
echo "Desktop OpenGL support is not avaliable on Qt for Embedded Linux"
exit 1
fi
# screen drivers
for screen in ${CFG_GFX_ON} ${CFG_GFX_PLUGIN}; do
if [ "${screen}" = "ahi" ] && [ "${CFG_CONFIGURE_EXIT_ON_ERROR}" = "yes" ]; then
"$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/qws/ahi "Ahi" $L_FLAGS $I_FLAGS $l_FLAGS
if [ $? != "0" ]; then
echo "The Ahi screen driver functionality test failed!"
echo " You might need to modify the include and library search paths by editing"
echo " QMAKE_INCDIR and QMAKE_LIBDIR in"
echo " ${XQMAKESPEC}."
exit 1
fi
fi
if [ "${screen}" = "svgalib" ] && [ "${CFG_CONFIGURE_EXIT_ON_ERROR}" = "yes" ]; then
"$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/qws/svgalib "SVGAlib" $L_FLAGS $I_FLAGS $l_FLAGS
if [ $? != "0" ]; then
echo "The SVGAlib screen driver functionality test failed!"
echo " You might need to modify the include and library search paths by editing"
echo " QMAKE_INCDIR and QMAKE_LIBDIR in"
echo " ${XQMAKESPEC}."
exit 1
fi
fi
if [ "${screen}" = "directfb" ] && [ "${CFG_CONFIGURE_EXIT_ON_ERROR}" = "yes" ]; then
if [ -n "$PKG_CONFIG" ]; then
if $PKG_CONFIG --exists directfb 2>/dev/null; then
QT_CFLAGS_DIRECTFB=`$PKG_CONFIG --cflags directfb 2>/dev/null`
QT_LIBS_DIRECTFB=`$PKG_CONFIG --libs directfb 2>/dev/null`
elif directfb-config --version >/dev/null 2>&1; then
QT_CFLAGS_DIRECTFB=`directfb-config --cflags 2>/dev/null`
QT_LIBS_DIRECTFB=`directfb-config --libs 2>/dev/null`
fi
fi
# QMake variables set here override those in the mkspec. Therefore we only set the variables here if they are not zero.
if [ -n "$QT_CFLAGS_DIRECTFB" ] || [ -n "$QT_LIBS_DIRECTFB" ]; then
QMakeVar set QT_CFLAGS_DIRECTFB "$QT_CFLAGS_DIRECTFB"
QMakeVar set QT_LIBS_DIRECTFB "$QT_LIBS_DIRECTFB"
fi
if [ "$CFG_QT3SUPPORT" = "yes" ]; then
QMakeVar set QT_DEFINES_DIRECTFB "QT3_SUPPORT"
fi
"$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/qws/directfb "DirectFB" $L_FLAGS $I_FLAGS $l_FLAGS $QT_CFLAGS_DIRECTFB $QT_LIBS_DIRECTFB
if [ $? != "0" ]; then
echo "The DirectFB screen driver functionality test failed!"
echo " You might need to modify the include and library search paths by editing"
echo " QT_CFLAGS_DIRECTFB and QT_LIBS_DIRECTFB in"
echo " ${XQMAKESPEC}."
exit 1
fi
fi
done
# mouse drivers
for mouse in ${CFG_MOUSE_ON} ${CFG_MOUSE_PLUGIN}; do
if [ "${mouse}" = "tslib" ] && [ "${CFG_CONFIGURE_EXIT_ON_ERROR}" = "yes" ]; then
"$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/tslib "tslib" $L_FLAGS $I_FLAGS $l_FLAGS
if [ $? != "0" ]; then
echo "The tslib functionality test failed!"
echo " You might need to modify the include and library search paths by editing"
echo " QMAKE_INCDIR and QMAKE_LIBDIR in"
echo " ${XQMAKESPEC}."
exit 1
fi
fi
done
CFG_QGTKSTYLE=no
# sound
"$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/qws/sound "sound" $L_FLAGS $I_FLAGS $l_FLAGS
if [ $? != "0" ]; then
QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_SOUND"
fi
fi # QWS
if [ "$CFG_ENDIAN" = "auto" ]; then
if [ "$PLATFORM_MAC" = "yes" ]; then
true #leave as auto
else
"$unixtests/endian.test" "$XQMAKESPEC" $OPT_VERBOSE "$relpath" "$outpath"
F="$?"
if [ "$F" -eq 0 ]; then
CFG_ENDIAN="Q_LITTLE_ENDIAN"
elif [ "$F" -eq 1 ]; then
CFG_ENDIAN="Q_BIG_ENDIAN"
else
echo
echo "The target system byte order could not be detected!"
echo "Turn on verbose messaging (-v) to see the final report."
echo "You can use the -little-endian or -big-endian switch to"
echo "$0 to continue."
exit 101
fi
fi
fi
if [ "$CFG_HOST_ENDIAN" = "auto" ]; then
if [ "$PLATFORM_MAC" = "yes" ]; then
true #leave as auto
else
"$unixtests/endian.test" "$QMAKESPEC" $OPT_VERBOSE "$relpath" "$outpath"
F="$?"
if [ "$F" -eq 0 ]; then
CFG_HOST_ENDIAN="Q_LITTLE_ENDIAN"
elif [ "$F" -eq 1 ]; then
CFG_HOST_ENDIAN="Q_BIG_ENDIAN"
else
echo
echo "The host system byte order could not be detected!"
echo "Turn on verbose messaging (-v) to see the final report."
echo "You can use the -host-little-endian or -host-big-endian switch to"
echo "$0 to continue."
exit 101
fi
fi
fi
if [ "$CFG_ARMFPA" != "auto" ]; then
if [ "$CFG_ARMFPA" = "yes" ]; then
if [ "$CFG_ENDIAN" = "Q_LITTLE_ENDIAN" ]; then
CFG_DOUBLEFORMAT="Q_DOUBLE_LITTLE_SWAPPED"
else
CFG_DOUBLEFORMAT="Q_DOUBLE_BIG_SWAPPED"
fi
else
CFG_DOUBLEFORMAT="normal"
fi
fi
if [ "$CFG_DOUBLEFORMAT" = "auto" ]; then
if [ "$PLATFORM_QWS" != "yes" ]; then
CFG_DOUBLEFORMAT=normal
else
"$unixtests/doubleformat.test" "$XQMAKESPEC" $OPT_VERBOSE "$relpath" "$outpath"
F="$?"
if [ "$F" -eq 10 ] && [ "$CFG_ENDIAN" = "Q_LITTLE_ENDIAN" ]; then
CFG_DOUBLEFORMAT=normal
elif [ "$F" -eq 11 ] && [ "$CFG_ENDIAN" = "Q_BIG_ENDIAN" ]; then
CFG_DOUBLEFORMAT=normal
elif [ "$F" -eq 10 ]; then
CFG_DOUBLEFORMAT="Q_DOUBLE_LITTLE"
elif [ "$F" -eq 11 ]; then
CFG_DOUBLEFORMAT="Q_DOUBLE_BIG"
elif [ "$F" -eq 12 ]; then
CFG_DOUBLEFORMAT="Q_DOUBLE_LITTLE_SWAPPED"
CFG_ARMFPA="yes"
elif [ "$F" -eq 13 ]; then
CFG_DOUBLEFORMAT="Q_DOUBLE_BIG_SWAPPED"
CFG_ARMFPA="yes"
else
echo
echo "The system floating point format could not be detected."
echo "This may cause data to be generated in a wrong format"
echo "Turn on verbose messaging (-v) to see the final report."
# we do not fail on this since this is a new test, and if it fails,
# the old behavior should be correct in most cases
CFG_DOUBLEFORMAT=normal
fi
fi
fi
# detect POSIX clock_gettime()
if [ "$CFG_CLOCK_GETTIME" = "auto" ]; then
if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/clock-gettime "POSIX clock_gettime()" $L_FLAGS $I_FLAGS $l_FLAGS; then
CFG_CLOCK_GETTIME=yes
else
CFG_CLOCK_GETTIME=no
fi
fi
# detect POSIX monotonic clocks
if [ "$CFG_CLOCK_GETTIME" = "yes" ] && [ "$CFG_CLOCK_MONOTONIC" = "auto" ]; then
if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/clock-monotonic "POSIX Monotonic Clock" $L_FLAGS $I_FLAGS $l_FLAGS; then
CFG_CLOCK_MONOTONIC=yes
else
CFG_CLOCK_MONOTONIC=no
fi
elif [ "$CFG_CLOCK_GETTIME" = "no" ]; then
CFG_CLOCK_MONOTONIC=no
fi
# detect mremap
if [ "$CFG_MREMAP" = "auto" ]; then
if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/mremap "mremap" $L_FLAGS $I_FLAGS $l_FLAGS; then
CFG_MREMAP=yes
else
CFG_MREMAP=no
fi
fi
# find if the platform provides getaddrinfo (ipv6 dns lookups)
if [ "$CFG_GETADDRINFO" != "no" ]; then
if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/getaddrinfo "getaddrinfo" $L_FLAGS $I_FLAGS $l_FLAGS; then
CFG_GETADDRINFO=yes
else
if [ "$CFG_GETADDRINFO" = "yes" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
echo "getaddrinfo support cannot be enabled due to functionality tests!"
echo " Turn on verbose messaging (-v) to $0 to see the final report."
echo " If you believe this message is in error you may use the continue"
echo " switch (-continue) to $0 to continue."
exit 101
else
CFG_GETADDRINFO=no
fi
fi
fi
# find if the platform provides if_nametoindex (ipv6 interface name support)
if [ "$CFG_IPV6IFNAME" != "no" ]; then
if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/ipv6ifname "IPv6 interface name" $L_FLAGS $I_FLAGS $l_FLAGS; then
CFG_IPV6IFNAME=yes
else
if [ "$CFG_IPV6IFNAME" = "yes" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
echo "IPv6 interface name support cannot be enabled due to functionality tests!"
echo " Turn on verbose messaging (-v) to $0 to see the final report."
echo " If you believe this message is in error you may use the continue"
echo " switch (-continue) to $0 to continue."
exit 101
else
CFG_IPV6IFNAME=no
fi
fi
fi
# find if the platform provides getifaddrs (network interface enumeration)
if [ "$CFG_GETIFADDRS" != "no" ]; then
if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/getifaddrs "getifaddrs" $L_FLAGS $I_FLAGS $l_FLAGS; then
CFG_GETIFADDRS=yes
else
if [ "$CFG_GETIFADDRS" = "yes" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
echo "getifaddrs support cannot be enabled due to functionality tests!"
echo " Turn on verbose messaging (-v) to $0 to see the final report."
echo " If you believe this message is in error you may use the continue"
echo " switch (-continue) to $0 to continue."
exit 101
else
CFG_GETIFADDRS=no
fi
fi
fi
# find if the platform supports X/Open Large File compilation environment
if [ "$CFG_LARGEFILE" != "no" ]; then
if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/largefile "X/Open Large File" $L_FLAGS $I_FLAGS $l_FLAGS; then
CFG_LARGEFILE=yes
else
if [ "$CFG_LARGEFILE" = "yes" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
echo "X/Open Large File support cannot be enabled due to functionality tests!"
echo " Turn on verbose messaging (-v) to $0 to see the final report."
echo " If you believe this message is in error you may use the continue"
echo " switch (-continue) to $0 to continue."
exit 101
else
CFG_LARGEFILE=no
fi
fi
fi
# detect OpenVG support
#QTP:QTPPROD-7 It is necessary to prohibit OpenVg checking for Symbian build
echo $XQMAKESPEC
if [ "$CFG_OPENVG" != "no" ] && [ "$XPLATFORM" != "symbian-sbsv2" ]; then
if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" "config.tests/unix/openvg" "OpenVG" $L_FLAGS $I_FLAGS $l_FLAGS $CONFIG_ARG; then
if [ "$CFG_OPENVG" = "auto" ]; then
CFG_OPENVG=yes
fi
elif "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG openvg_on_opengl" $OPT_VERBOSE "$relpath" "$outpath" "config.tests/unix/openvg" "OpenVG" $L_FLAGS $I_FLAGS $l_FLAGS $CONFIG_ARG; then
if [ "$CFG_OPENVG" = "auto" ]; then
CFG_OPENVG=yes
fi
CFG_OPENVG_ON_OPENGL=yes
elif "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG lower_case_includes" $OPT_VERBOSE "$relpath" "$outpath" "config.tests/unix/openvg" "OpenVG (lc includes)" $L_FLAGS $I_FLAGS $l_FLAGS $CONFIG_ARG; then
if [ "$CFG_OPENVG" = "auto" ]; then
CFG_OPENVG=yes
fi
CFG_OPENVG_LC_INCLUDES=yes
elif "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG openvg_on_opengl lower_case_includes" $OPT_VERBOSE "$relpath" "$outpath" "config.tests/unix/openvg" "OpenVG (lc includes)" $L_FLAGS $I_FLAGS $l_FLAGS $CONFIG_ARG; then
if [ "$CFG_OPENVG" = "auto" ]; then
CFG_OPENVG=yes
fi
CFG_OPENVG_LC_INCLUDES=yes
CFG_OPENVG_ON_OPENGL=yes
else
if [ "$CFG_OPENVG" != "auto" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
echo "$CFG_OPENVG was specified for OpenVG but cannot be enabled due to functionality tests!"
echo " Turn on verbose messaging (-v) to $0 to see the final report."
echo " If you believe this message is in error you may use the continue"
echo " switch (-continue) to $0 to continue."
exit 101
else
CFG_OPENVG=no
fi
fi
if [ "$CFG_OPENVG" = "yes" ] && "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" "config.tests/unix/shivavg" "ShivaVG" $L_FLAGS $I_FLAGS $l_FLAGS $CONFIG_ARG; then
CFG_OPENVG_SHIVA=yes
fi
fi
# if openvg is disabled and the user specified graphicssystem vg, disable it...
if [ "$CFG_GRAPHICS_SYSTEM" = "openvg" ] && [ "$CFG_OPENVG" = "no" ]; then
echo "OpenVG Graphics System is disabled due to missing OpenVG support..."
CFG_GRAPHICS_SYSTEM=default
fi
if [ "$CFG_PTMALLOC" != "no" ]; then
# build ptmalloc, copy .a file to lib/
echo "Building ptmalloc. Please wait..."
(cd "$relpath/src/3rdparty/ptmalloc/"; "$MAKE" "clean" ; "$MAKE" "posix"
mkdir "$outpath/lib/" ; cp "libptmalloc3.a" "$outpath/lib/")
QMakeVar add QMAKE_LFLAGS "$outpath/lib/libptmalloc3.a"
fi
if [ "$CFG_ALSA" = "auto" ]; then
if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/alsa "alsa" $L_FLAGS $I_FLAGS $l_FLAGS; then
CFG_ALSA=yes
else
CFG_ALSA=no
fi
fi
if [ -f "$relpath/src/declarative/declarative.pro" ]; then
if [ "$CFG_DECLARATIVE" = "auto" ]; then
CFG_DECLARATIVE=yes
fi
else
if [ "$CFG_DECLARATIVE" = "auto" ] || [ "$CFG_DECLARATIVE" = "no" ]; then
CFG_DECLARATIVE=no
else
echo "Error: Unable to locate the qt-declarative package. Refer to the documentation on how to build the package."
exit 1
fi
fi
if [ "$CFG_JAVASCRIPTCORE_JIT" = "yes" ] || [ "$CFG_JAVASCRIPTCORE_JIT" = "auto" ]; then
if [ "$CFG_ARCH" = "arm" ] || [ "$CFG_ARCH" = "armv6" ]; then
"$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/javascriptcore-jit "javascriptcore-jit" $L_FLAGS $I_FLAGS $l_FLAGS
if [ $? != "0" ]; then
CFG_JAVASCRIPTCORE_JIT=no
fi
fi
fi
if [ "$CFG_JAVASCRIPTCORE_JIT" = "yes" ]; then
QMakeVar set JAVASCRIPTCORE_JIT yes
elif [ "$CFG_JAVASCRIPTCORE_JIT" = "no" ]; then
QMakeVar set JAVASCRIPTCORE_JIT no
fi
#-------------------------------------------------------------------------------
# ask for all that hasn't been auto-detected or specified in the arguments
#-------------------------------------------------------------------------------
### fix this: user input should be validated in a loop
if [ "$CFG_QWS_DEPTHS" = "prompted" -a "$PLATFORM_QWS" = "yes" ]; then
echo
echo "Choose pixel-depths to support:"
echo
echo " 1. 1bpp, black/white"
echo " 4. 4bpp, grayscale"
echo " 8. 8bpp, paletted"
echo " 12. 12bpp, rgb 4-4-4"
echo " 15. 15bpp, rgb 5-5-5"
echo " 16. 16bpp, rgb 5-6-5"
echo " 18. 18bpp, rgb 6-6-6"
echo " 24. 24bpp, rgb 8-8-8"
echo " 32. 32bpp, argb 8-8-8-8 and rgb 8-8-8"
echo " all. All supported depths"
echo
echo "Your choices (default 8,16,32):"
read CFG_QWS_DEPTHS
if [ -z "$CFG_QWS_DEPTHS" ] || [ "$CFG_QWS_DEPTHS" = "yes" ]; then
CFG_QWS_DEPTHS=8,16,32
fi
fi
if [ -n "$CFG_QWS_DEPTHS" -a "$PLATFORM_QWS" = "yes" ]; then
if [ "$CFG_QWS_DEPTHS" = "all" ]; then
CFG_QWS_DEPTHS="1 4 8 12 15 16 18 24 32 generic"
fi
for D in `echo "$CFG_QWS_DEPTHS" | sed -e 's/,/ /g'`; do
case $D in
1|4|8|12|15|16|18|24|32) QCONFIG_FLAGS="$QCONFIG_FLAGS QT_QWS_DEPTH_$D";;
generic) QCONFIG_FLAGS="$QCONFIG_FLAGS QT_QWS_DEPTH_GENERIC";;
esac
done
fi
# enable dwarf2 support on Mac
if [ "$CFG_MAC_DWARF2" = "yes" ]; then
QT_CONFIG="$QT_CONFIG dwarf2"
fi
# Set the default arch.
# Carbon builds: 32 bit x86/ppc.
# For "-cocoa" builds on snow leopard : compiler default (64-bit).
# For "-cocoa" builds on leopard : compiler default (32-bit).
if [ "$PLATFORM_MAC" = "yes" ] && [ "$CFG_MAC_ARCHS" = "" ]; then
source "$mactests/defaultarch.test" "$TEST_COMPILER" "$OPT_VERBOSE" "$mactests"
if [ "$CFG_MAC_COCOA" != "yes" ]; then
if [ "$QT_MAC_DEFAULT_ARCH" = "x86_64" ]; then
CFG_MAC_ARCHS=" x86"
elif [ "$QT_MAC_DEFAULT_ARCH" = "ppc64" ]; then
CFG_MAC_ARCHS=" ppc"
else
CFG_MAC_ARCHS=" $QT_MAC_DEFAULT_ARCH"
fi
else
CFG_MAC_ARCHS=" $QT_MAC_DEFAULT_ARCH"
fi
[ "$OPT_VERBOSE" = "yes" ] && echo "Setting Mac architechture to$CFG_MAC_ARCHS."
fi
# enable cocoa and/or carbon on Mac
if [ "$CFG_MAC_COCOA" = "yes" ]; then
# -cocoa on the command line disables carbon completely (i.e. use cocoa for 32-bit as well)
CFG_MAC_CARBON="no"
else
# check which archs are in use, enable cocoa if we find a 64-bit one
if echo "$CFG_MAC_ARCHS" | grep 64 > /dev/null 2>&1; then
CFG_MAC_COCOA="yes";
CFG_MAC_CARBON="no";
if echo "$CFG_MAC_ARCHS" | grep -w ppc > /dev/null 2>&1; then
CFG_MAC_CARBON="yes";
fi
if echo "$CFG_MAC_ARCHS" | grep -w x86 > /dev/null 2>&1; then
CFG_MAC_CARBON="yes";
fi
else
# no 64-bit archs found.
CFG_MAC_COCOA="no"
fi
fi;
# set the global Mac deployment target. This is overridden on an arch-by-arch basis
# in some cases, see code further down
case "$PLATFORM,$CFG_MAC_COCOA" in
macx*,yes)
# Cocoa
QMakeVar set QMAKE_MACOSX_DEPLOYMENT_TARGET 10.5
;;
macx*,no)
# gcc, Carbon
QMakeVar set QMAKE_MACOSX_DEPLOYMENT_TARGET 10.4
;;
esac
# disable Qt 3 support on VxWorks
case "$XPLATFORM" in
unsupported/vxworks*)
CFG_QT3SUPPORT="no"
;;
esac
# enable Qt 3 support functionality
if [ "$CFG_QT3SUPPORT" = "yes" ]; then
QT_CONFIG="$QT_CONFIG qt3support"
fi
# enable Phonon
if [ "$CFG_PHONON" = "yes" ]; then
QT_CONFIG="$QT_CONFIG phonon"
if [ "$CFG_PHONON_BACKEND" = "yes" ]; then
QT_CONFIG="$QT_CONFIG phonon-backend"
fi
else
QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_PHONON"
fi
# disable accessibility
if [ "$CFG_ACCESSIBILITY" = "no" ]; then
QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_ACCESSIBILITY"
else
QT_CONFIG="$QT_CONFIG accessibility"
fi
# enable egl
if [ "$CFG_EGL" = "no" ]; then
QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_EGL"
else
QT_CONFIG="$QT_CONFIG egl"
if [ "$CFG_EGL_GLES_INCLUDES" = "yes" ]; then
QCONFIG_FLAGS="$QCONFIG_FLAGS QT_GLES_EGL"
fi
fi
# enable openvg
if [ "$CFG_OPENVG" = "no" ]; then
QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_OPENVG"
else
QT_CONFIG="$QT_CONFIG openvg"
if [ "$CFG_OPENVG_LC_INCLUDES" = "yes" ]; then
QCONFIG_FLAGS="$QCONFIG_FLAGS QT_LOWER_CASE_VG_INCLUDES"
fi
if [ "$CFG_OPENVG_ON_OPENGL" = "yes" ]; then
QT_CONFIG="$QT_CONFIG openvg_on_opengl"
fi
if [ "$CFG_OPENVG_SHIVA" = "yes" ]; then
QT_CONFIG="$QT_CONFIG shivavg"
QCONFIG_FLAGS="$QCONFIG_FLAGS QT_SHIVAVG"
fi
fi
# QTP:QTPROD-7 Cross compiling on Linux broken
if [ "$QT_SYMBIAN_STYLE_FLAGS" = "no" ]; then
QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_STYLE_S60"
else
QCONFIG_FLAGS="$QCONFIG_FLAGS QT_STYLE_S60"
fi
# enable opengl
if [ "$CFG_OPENGL" = "no" ]; then
QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_OPENGL"
else
QT_CONFIG="$QT_CONFIG opengl"
fi
if [ "$CFG_OPENGL" = "es1" ] || [ "$CFG_OPENGL" = "es1cl" ] || [ "$CFG_OPENGL" = "es2" ]; then
if [ "$PLATFORM_QWS" = "yes" ]; then
QCONFIG_FLAGS="$QCONFIG_FLAGS Q_BACKINGSTORE_SUBSURFACES"
QCONFIG_FLAGS="$QCONFIG_FLAGS Q_USE_EGLWINDOWSURFACE"
fi
QCONFIG_FLAGS="$QCONFIG_FLAGS QT_OPENGL_ES"
fi
if [ "$CFG_OPENGL" = "es1" ]; then
QCONFIG_FLAGS="$QCONFIG_FLAGS QT_OPENGL_ES_1"
QT_CONFIG="$QT_CONFIG opengles1"
fi
if [ "$CFG_OPENGL" = "es1cl" ]; then
QCONFIG_FLAGS="$QCONFIG_FLAGS QT_OPENGL_ES_1_CL"
QT_CONFIG="$QT_CONFIG opengles1cl"
fi
if [ "$CFG_OPENGL" = "es2" ]; then
QCONFIG_FLAGS="$QCONFIG_FLAGS QT_OPENGL_ES_2"
QT_CONFIG="$QT_CONFIG opengles2"
fi
# safe execution environment
# it is not support in the Symbian. Comment it.
#if [ "$CFG_SXE" != "no" ]; then
# QT_CONFIG="$QT_CONFIG sxe"
#fi
# build up the variables for output
if [ "$CFG_DEBUG" = "yes" ]; then
QMAKE_OUTDIR="${QMAKE_OUTDIR}debug"
QMAKE_CONFIG="$QMAKE_CONFIG debug"
elif [ "$CFG_DEBUG" = "no" ]; then
QMAKE_OUTDIR="${QMAKE_OUTDIR}release"
QMAKE_CONFIG="$QMAKE_CONFIG release"
fi
if [ "$CFG_SHARED" = "yes" ]; then
QMAKE_OUTDIR="${QMAKE_OUTDIR}-shared"
QMAKE_CONFIG="$QMAKE_CONFIG shared dll"
elif [ "$CFG_SHARED" = "no" ]; then
QMAKE_OUTDIR="${QMAKE_OUTDIR}-static"
QMAKE_CONFIG="$QMAKE_CONFIG static"
fi
if [ "$PLATFORM_QWS" = "yes" ]; then
QMAKE_OUTDIR="${QMAKE_OUTDIR}-emb-$CFG_EMBEDDED"
QMAKE_CONFIG="$QMAKE_CONFIG embedded"
QT_CONFIG="$QT_CONFIG embedded"
rm -f "src/.moc/$QMAKE_OUTDIR/allmoc.cpp" # needs remaking if config changes
fi
QMakeVar set PRECOMPILED_DIR ".pch/$QMAKE_OUTDIR"
QMakeVar set OBJECTS_DIR ".obj/$QMAKE_OUTDIR"
QMakeVar set MOC_DIR ".moc/$QMAKE_OUTDIR"
QMakeVar set RCC_DIR ".rcc/$QMAKE_OUTDIR"
QMakeVar set UI_DIR ".uic/$QMAKE_OUTDIR"
if [ "$CFG_LARGEFILE" = "yes" ]; then
QMAKE_CONFIG="$QMAKE_CONFIG largefile"
fi
if [ "$CFG_STL" = "no" ]; then
QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_STL"
else
QMAKE_CONFIG="$QMAKE_CONFIG stl"
fi
if [ "$CFG_USE_GNUMAKE" = "yes" ]; then
QMAKE_CONFIG="$QMAKE_CONFIG GNUmake"
fi
[ "$CFG_REDUCE_EXPORTS" = "yes" ] && QT_CONFIG="$QT_CONFIG reduce_exports"
[ "$CFG_REDUCE_RELOCATIONS" = "yes" ] && QT_CONFIG="$QT_CONFIG reduce_relocations"
[ "$CFG_PRECOMPILE" = "yes" ] && QMAKE_CONFIG="$QMAKE_CONFIG precompile_header"
if [ "$CFG_SEPARATE_DEBUG_INFO" = "yes" ]; then
QMakeVar add QMAKE_CFLAGS -g
QMakeVar add QMAKE_CXXFLAGS -g
QMAKE_CONFIG="$QMAKE_CONFIG separate_debug_info"
fi
[ "$CFG_MMX" = "yes" ] && QMAKE_CONFIG="$QMAKE_CONFIG mmx"
[ "$CFG_3DNOW" = "yes" ] && QMAKE_CONFIG="$QMAKE_CONFIG 3dnow"
[ "$CFG_SSE" = "yes" ] && QMAKE_CONFIG="$QMAKE_CONFIG sse"
[ "$CFG_SSE2" = "yes" ] && QMAKE_CONFIG="$QMAKE_CONFIG sse2"
[ "$CFG_IWMMXT" = "yes" ] && QMAKE_CONFIG="$QMAKE_CONFIG iwmmxt"
[ "$PLATFORM_MAC" = "yes" ] && QMAKE_CONFIG="$QMAKE_CONFIG $CFG_MAC_ARCHS"
if [ "$CFG_IPV6" = "yes" ]; then
QT_CONFIG="$QT_CONFIG ipv6"
fi
if [ "$CFG_CLOCK_GETTIME" = "yes" ]; then
QT_CONFIG="$QT_CONFIG clock-gettime"
fi
if [ "$CFG_CLOCK_MONOTONIC" = "yes" ]; then
QT_CONFIG="$QT_CONFIG clock-monotonic"
fi
if [ "$CFG_MREMAP" = "yes" ]; then
QT_CONFIG="$QT_CONFIG mremap"
fi
if [ "$CFG_GETADDRINFO" = "yes" ]; then
QT_CONFIG="$QT_CONFIG getaddrinfo"
fi
if [ "$CFG_IPV6IFNAME" = "yes" ]; then
QT_CONFIG="$QT_CONFIG ipv6ifname"
fi
if [ "$CFG_GETIFADDRS" = "yes" ]; then
QT_CONFIG="$QT_CONFIG getifaddrs"
fi
if [ "$CFG_INOTIFY" = "yes" ]; then
QT_CONFIG="$QT_CONFIG inotify"
fi
if [ "$CFG_LIBJPEG" = "no" ]; then
CFG_JPEG="no"
elif [ "$CFG_LIBJPEG" = "system" ]; then
QT_CONFIG="$QT_CONFIG system-jpeg"
fi
if [ "$CFG_JPEG" = "no" ]; then
QT_CONFIG="$QT_CONFIG no-jpeg"
elif [ "$CFG_JPEG" = "yes" ]; then
QT_CONFIG="$QT_CONFIG jpeg"
fi
if [ "$CFG_LIBMNG" = "no" ]; then
CFG_MNG="no"
elif [ "$CFG_LIBMNG" = "system" ]; then
QT_CONFIG="$QT_CONFIG system-mng"
fi
if [ "$CFG_MNG" = "no" ]; then
QT_CONFIG="$QT_CONFIG no-mng"
elif [ "$CFG_MNG" = "yes" ]; then
QT_CONFIG="$QT_CONFIG mng"
fi
if [ "$CFG_LIBPNG" = "no" ]; then
CFG_PNG="no"
fi
if [ "$CFG_LIBPNG" = "system" ]; then
QT_CONFIG="$QT_CONFIG system-png"
fi
if [ "$CFG_PNG" = "no" ]; then
QT_CONFIG="$QT_CONFIG no-png"
elif [ "$CFG_PNG" = "yes" ]; then
QT_CONFIG="$QT_CONFIG png"
fi
if [ "$CFG_GIF" = "no" ]; then
QT_CONFIG="$QT_CONFIG no-gif"
elif [ "$CFG_GIF" = "yes" ]; then
QT_CONFIG="$QT_CONFIG gif"
fi
if [ "$CFG_LIBTIFF" = "no" ]; then
CFG_TIFF="no"
elif [ "$CFG_LIBTIFF" = "system" ]; then
QT_CONFIG="$QT_CONFIG system-tiff"
fi
if [ "$CFG_TIFF" = "no" ]; then
QT_CONFIG="$QT_CONFIG no-tiff"
elif [ "$CFG_TIFF" = "yes" ]; then
QT_CONFIG="$QT_CONFIG tiff"
fi
if [ "$CFG_LIBFREETYPE" = "no" ]; then
if [ "$XPLATFORM" != "symbian-sbsv2" ]; then
QT_CONFIG="$QT_CONFIG no-freetype"
fi
elif [ "$CFG_LIBFREETYPE" = "system" ]; then
QT_CONFIG="$QT_CONFIG system-freetype"
else
QT_CONFIG="$QT_CONFIG freetype"
fi
if [ "x$PLATFORM_MAC" = "xyes" ]; then
#On Mac we implicitly link against libz, so we
#never use the 3rdparty stuff.
[ "$CFG_ZLIB" = "yes" ] && CFG_ZLIB="system"
fi
if [ "$CFG_ZLIB" = "yes" ]; then
QT_CONFIG="$QT_CONFIG zlib"
elif [ "$CFG_ZLIB" = "system" ]; then
QT_CONFIG="$QT_CONFIG system-zlib"
fi
[ "$CFG_NIS" = "yes" ] && QT_CONFIG="$QT_CONFIG nis"
[ "$CFG_CUPS" = "yes" ] && QT_CONFIG="$QT_CONFIG cups"
[ "$CFG_ICONV" = "yes" ] && QT_CONFIG="$QT_CONFIG iconv"
[ "$CFG_ICONV" = "gnu" ] && QT_CONFIG="$QT_CONFIG gnu-libiconv"
[ "$CFG_GLIB" = "yes" ] && QT_CONFIG="$QT_CONFIG glib"
[ "$CFG_GSTREAMER" = "yes" ] && QT_CONFIG="$QT_CONFIG gstreamer"
[ "$CFG_DBUS" = "yes" ] && QT_CONFIG="$QT_CONFIG dbus"
[ "$CFG_DBUS" = "linked" ] && QT_CONFIG="$QT_CONFIG dbus dbus-linked"
[ "$CFG_NAS" = "system" ] && QT_CONFIG="$QT_CONFIG nas"
[ "$CFG_OPENSSL" = "yes" ] && QT_CONFIG="$QT_CONFIG openssl"
[ "$CFG_OPENSSL" = "linked" ] && QT_CONFIG="$QT_CONFIG openssl-linked"
if [ "$PLATFORM_X11" = "yes" ]; then
[ "$CFG_SM" = "yes" ] && QT_CONFIG="$QT_CONFIG x11sm"
# for some reason, the following libraries are not always built shared,
# so *every* program/lib (including Qt) has to link against them
if [ "$CFG_XSHAPE" = "yes" ]; then
QT_CONFIG="$QT_CONFIG xshape"
fi
if [ "$CFG_XSYNC" = "yes" ]; then
QT_CONFIG="$QT_CONFIG xsync"
fi
if [ "$CFG_XINERAMA" = "yes" ]; then
QT_CONFIG="$QT_CONFIG xinerama"
QMakeVar set QMAKE_LIBS_X11 '-lXinerama $$QMAKE_LIBS_X11'
fi
if [ "$CFG_XCURSOR" = "yes" ]; then
QT_CONFIG="$QT_CONFIG xcursor"
QMakeVar set QMAKE_LIBS_X11 '-lXcursor $$QMAKE_LIBS_X11'
fi
if [ "$CFG_XFIXES" = "yes" ]; then
QT_CONFIG="$QT_CONFIG xfixes"
QMakeVar set QMAKE_LIBS_X11 '-lXfixes $$QMAKE_LIBS_X11'
fi
if [ "$CFG_XRANDR" = "yes" ]; then
QT_CONFIG="$QT_CONFIG xrandr"
if [ "$CFG_XRENDER" != "yes" ]; then
# libXrandr uses 1 function from libXrender, so we always have to have it :/
QMakeVar set QMAKE_LIBS_X11 '-lXrandr -lXrender $$QMAKE_LIBS_X11'
else
QMakeVar set QMAKE_LIBS_X11 '-lXrandr $$QMAKE_LIBS_X11'
fi
fi
if [ "$CFG_XRENDER" = "yes" ]; then
QT_CONFIG="$QT_CONFIG xrender"
QMakeVar set QMAKE_LIBS_X11 '-lXrender $$QMAKE_LIBS_X11'
fi
if [ "$CFG_MITSHM" = "yes" ]; then
QT_CONFIG="$QT_CONFIG mitshm"
fi
if [ "$CFG_FONTCONFIG" = "yes" ]; then
QT_CONFIG="$QT_CONFIG fontconfig"
fi
if [ "$CFG_XINPUT" = "yes" ]; then
QMakeVar set QMAKE_LIBS_X11 '-lXi $$QMAKE_LIBS_X11'
fi
if [ "$CFG_XINPUT" = "yes" ]; then
QT_CONFIG="$QT_CONFIG xinput tablet"
fi
if [ "$CFG_XKB" = "yes" ]; then
QT_CONFIG="$QT_CONFIG xkb"
fi
fi
[ '!' -z "$D_FLAGS" ] && QMakeVar add DEFINES "$D_FLAGS"
[ '!' -z "$L_FLAGS" ] && QMakeVar add QMAKE_LIBDIR_FLAGS "$L_FLAGS"
[ '!' -z "$l_FLAGS" ] && QMakeVar add LIBS "$l_FLAGS"
if [ "$PLATFORM_MAC" = "yes" ]; then
if [ "$CFG_RPATH" = "yes" ]; then
QMAKE_CONFIG="$QMAKE_CONFIG absolute_library_soname"
fi
elif [ -z "`getQMakeConf \"$XQMAKESPEC\" | grep QMAKE_RPATH | awk '{print $3;}'`" ]; then
if [ -n "$RPATH_FLAGS" ]; then
echo
echo "ERROR: -R cannot be used on this platform as \$QMAKE_RPATH is"
echo " undefined."
echo
exit 1
elif [ "$CFG_RPATH" = "yes" ]; then
RPATH_MESSAGE=" NOTE: This platform does not support runtime library paths, using -no-rpath."
CFG_RPATH=no
fi
else
if [ "$CFG_RPATH" = "yes" ]; then
# set the default rpath to the library installation directory
RPATH_FLAGS="\"$QT_INSTALL_LIBS\" $RPATH_FLAGS"
fi
if [ -n "$RPATH_FLAGS" ]; then
# add the user defined rpaths
QMakeVar add QMAKE_RPATHDIR "$RPATH_FLAGS"
fi
fi
if [ '!' -z "$I_FLAGS" ]; then
# add the user define include paths
QMakeVar add QMAKE_CFLAGS "$I_FLAGS"
QMakeVar add QMAKE_CXXFLAGS "$I_FLAGS"
fi
# turn off exceptions for the compilers that support it
if [ "$PLATFORM_QWS" = "yes" ]; then
COMPILER=`echo $XPLATFORM | cut -f 3- -d-`
else
COMPILER=`echo $PLATFORM | cut -f 2- -d-`
fi
if [ "$CFG_EXCEPTIONS" = "unspecified" -a "$PLATFORM_QWS" = "yes" ]; then
CFG_EXCEPTIONS=no
fi
if [ "$CFG_EXCEPTIONS" != "no" ]; then
QTCONFIG_CONFIG="$QTCONFIG_CONFIG exceptions"
fi
if [ "$CFG_ALSA" = "yes" ]; then
QT_CONFIG="$QT_CONFIG alsa"
fi
#
# Some Qt modules are too advanced in C++ for some old compilers
# Detect here the platforms where they are known to work.
#
# See Qt documentation for more information on which features are
# supported and on which compilers.
#
canBuildQtXmlPatterns="yes"
canBuildWebKit="$HAVE_STL"
canBuildQtConcurrent="yes"
# WebKit requires stdint.h
"$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/stdint "Stdint" $L_FLAGS $I_FLAGS $l_FLAGS
if [ $? != "0" ]; then
canBuildWebKit="no"
fi
case "$XPLATFORM" in
hpux-g++*)
# PA-RISC's assembly is too limited
# gcc 3.4 on that platform can't build QtXmlPatterns
# the assembly it generates cannot be compiled
# Check gcc's version
case "$(${QMAKE_CONF_COMPILER} -dumpversion)" in
4*)
;;
3.4*)
canBuildQtXmlPatterns="no"
;;
*)
canBuildWebKit="no"
canBuildQtXmlPatterns="no"
;;
esac
;;
unsupported/vxworks-*-g++*)
canBuildWebKit="no"
;;
unsupported/vxworks-*-dcc*)
canBuildWebKit="no"
canBuildQtXmlPatterns="no"
;;
*-g++*)
# Check gcc's version
case "$(${QMAKE_CONF_COMPILER} -dumpversion)" in
4*|3.4*)
;;
3.3*)
canBuildWebKit="no"
;;
*)
canBuildWebKit="no"
canBuildQtXmlPatterns="no"
;;
esac
;;
solaris-cc*)
# Check the compiler version
case `${QMAKE_CONF_COMPILER} -V 2>&1 | awk '{print $4}'` in
5.[012345678])
canBuildWebKit="no"
canBuildQtXmlPatterns="no"
canBuildQtConcurrent="no"
;;
5.9)
canBuildWebKit="no"
canBuildQtConcurrent="no"
;;
esac
;;
hpux-acc*)
canBuildWebKit="no"
canBuildQtXmlPatterns="no"
canBuildQtConcurrent="no"
;;
hpuxi-acc*)
canBuildWebKit="no"
;;
aix-xlc*)
# Get the xlC version
cat > xlcver.c <<EOF
#include <stdio.h>
int main()
{
printf("%d.%d\n", __xlC__ >> 8, __xlC__ & 0xFF);
return 0;
}
EOF
xlcver=
if ${QMAKE_CONF_COMPILER} -o xlcver xlcver.c >/dev/null 2>/dev/null; then
xlcver=`./xlcver 2>/dev/null`
rm -f ./xlcver
fi
if [ "$OPT_VERBOSE" = "yes" ]; then
if [ -n "$xlcver" ]; then
echo Found IBM xlC version: $xlcver.
else
echo Could not determine IBM xlC version, assuming oldest supported.
fi
fi
case "$xlcver" in
[123456].*)
canBuildWebKit="no"
canBuildQtXmlPatterns="no"
canBuildQtConcurrent="no"
;;
*)
canBuildWebKit="no"
canBuildQtConcurrent="no"
;;
esac
;;
irix-cc*)
canBuildWebKit="no"
canBuildQtConcurrent="no"
;;
esac
CFG_CONCURRENT="yes"
if [ "$canBuildQtConcurrent" = "no" ]; then
QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_CONCURRENT"
CFG_CONCURRENT="no"
fi
if [ "$CFG_XMLPATTERNS" = "yes" -a "$CFG_EXCEPTIONS" = "no" ]; then
echo "QtXmlPatterns was requested, but it can't be built due to exceptions being disabled."
exit 1
fi
if [ "$CFG_XMLPATTERNS" = "auto" -a "$CFG_EXCEPTIONS" != "no" ]; then
CFG_XMLPATTERNS="$canBuildQtXmlPatterns"
elif [ "$CFG_EXCEPTIONS" = "no" ]; then
CFG_XMLPATTERNS="no"
fi
if [ "$CFG_XMLPATTERNS" = "yes" ]; then
QT_CONFIG="$QT_CONFIG xmlpatterns"
else
QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_XMLPATTERNS"
fi
if [ "$CFG_MULTIMEDIA" = "no" ]; then
QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_MULTIMEDIA"
else
QT_CONFIG="$QT_CONFIG multimedia"
fi
if [ "$CFG_SVG" = "yes" ]; then
QT_CONFIG="$QT_CONFIG svg"
else
QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_SVG"
fi
if [ "$CFG_DECLARATIVE" = "yes" ]; then
QT_CONFIG="$QT_CONFIG declarative"
else
QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_DECLARATIVE"
fi
if [ "$CFG_WEBKIT" = "auto" ]; then
CFG_WEBKIT="$canBuildWebKit"
fi
if [ "$CFG_WEBKIT" = "yes" ]; then
QT_CONFIG="$QT_CONFIG webkit"
# The reason we set CFG_WEBKIT, is such that the printed overview of what will be enabled, shows correctly.
CFG_WEBKIT="yes"
else
CFG_WEBKIT="no"
QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_WEBKIT"
fi
if [ "$CFG_SCRIPT" = "auto" ]; then
CFG_SCRIPT="yes"
fi
if [ "$CFG_SCRIPT" = "yes" ]; then
QT_CONFIG="$QT_CONFIG script"
else
QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_SCRIPT"
fi
if [ "$CFG_SCRIPTTOOLS" = "yes" -a "$CFG_SCRIPT" = "no" ]; then
echo "QtScriptTools was requested, but it can't be built due to QtScript being disabled."
exit 1
fi
if [ "$CFG_SCRIPTTOOLS" = "auto" -a "$CFG_SCRIPT" != "no" ]; then
CFG_SCRIPTTOOLS="yes"
elif [ "$CFG_SCRIPT" = "no" ]; then
CFG_SCRIPTTOOLS="no"
fi
if [ "$CFG_SCRIPTTOOLS" = "yes" ]; then
QT_CONFIG="$QT_CONFIG scripttools"
else
QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_SCRIPTTOOLS"
fi
if [ "$CFG_EXCEPTIONS" = "no" ]; then
case "$COMPILER" in
g++*)
QMakeVar add QMAKE_CFLAGS -fno-exceptions
QMakeVar add QMAKE_CXXFLAGS -fno-exceptions
QMakeVar add QMAKE_LFLAGS -fno-exceptions
;;
cc*)
case "$PLATFORM" in
irix-cc*)
QMakeVar add QMAKE_CFLAGS -LANG:exceptions=off
QMakeVar add QMAKE_CXXFLAGS -LANG:exceptions=off
QMakeVar add QMAKE_LFLAGS -LANG:exceptions=off
;;
*) ;;
esac
;;
*) ;;
esac
QMAKE_CONFIG="$QMAKE_CONFIG exceptions_off"
fi
# On Mac, set the minimum deployment target for the different architechtures
# using the Xarch compiler option when supported (10.5 and up). On 10.4 the
# deployment version is set to 10.4 globally using the QMAKE_MACOSX_DEPLOYMENT_TARGET
# env. variable. "-cocoa" on the command line means Cocoa is used in 32-bit mode also,
# in this case fall back on QMAKE_MACOSX_DEPLOYMENT_TARGET which will be set to 10.5.
if [ "$PLATFORM_MAC" = "yes" ] && [ "$CFG_MAC_XARCH" != "no" ] && [ "$COMMANDLINE_MAC_COCOA" != "yes" ]; then
if echo "$CFG_MAC_ARCHS" | grep '\<x86\>' > /dev/null 2>&1; then
QMakeVar add QMAKE_CFLAGS "-Xarch_i386 -mmacosx-version-min=10.4"
QMakeVar add QMAKE_CXXFLAGS "-Xarch_i386 -mmacosx-version-min=10.4"
QMakeVar add QMAKE_LFLAGS "-Xarch_i386 -mmacosx-version-min=10.4"
QMakeVar add QMAKE_OBJECTIVE_CFLAGS_X86 "-arch i386 -Xarch_i386 -mmacosx-version-min=10.4"
fi
if echo "$CFG_MAC_ARCHS" | grep '\<ppc\>' > /dev/null 2>&1; then
QMakeVar add QMAKE_CFLAGS "-Xarch_ppc -mmacosx-version-min=10.4"
QMakeVar add QMAKE_CXXFLAGS "-Xarch_ppc -mmacosx-version-min=10.4"
QMakeVar add QMAKE_LFLAGS "-Xarch_ppc -mmacosx-version-min=10.4"
QMakeVar add QMAKE_OBJECTIVE_CFLAGS_PPC "-arch ppc -Xarch_ppc -mmacosx-version-min=10.4"
fi
if echo "$CFG_MAC_ARCHS" | grep '\<x86_64\>' > /dev/null 2>&1; then
QMakeVar add QMAKE_CFLAGS "-Xarch_x86_64 -mmacosx-version-min=10.5"
QMakeVar add QMAKE_CXXFLAGS "-Xarch_x86_64 -mmacosx-version-min=10.5"
QMakeVar add QMAKE_LFLAGS "-Xarch_x86_64 -mmacosx-version-min=10.5"
QMakeVar add QMAKE_OBJECTIVE_CFLAGS_X86_64 "-arch x86_64 -Xarch_x86_64 -mmacosx-version-min=10.5"
fi
if echo "$CFG_MAC_ARCHS" | grep '\<ppc64\>' > /dev/null 2>&1; then
QMakeVar add QMAKE_CFLAGS "-Xarch_ppc64 -mmacosx-version-min=10.5"
QMakeVar add QMAKE_CXXFLAGS "-Xarch_ppc64 -mmacosx-version-min=10.5"
QMakeVar add QMAKE_LFLAGS "-Xarch_ppc64 -mmacosx-version-min=10.5"
QMakeVar add QMAKE_OBJECTIVE_CFLAGS_PPC_64 "-arch ppc64 -Xarch_ppc64 -mmacosx-version-min=10.5"
fi
fi
#-------------------------------------------------------------------------------
# generate QT_BUILD_KEY
#-------------------------------------------------------------------------------
# some compilers generate binary incompatible code between different versions,
# so we need to generate a build key that is different between these compilers
case "$COMPILER" in
g++*)
# GNU C++
COMPILER_VERSION=`${QMAKE_CONF_COMPILER} -dumpversion 2>/dev/null`
case "$COMPILER_VERSION" in
*.*.*)
QT_GCC_MAJOR_VERSION=`echo $COMPILER_VERSION | sed 's,^\([0-9]*\)\.\([0-9]*\)\.\([0-9]*\).*,\1,'`
QT_GCC_MINOR_VERSION=`echo $COMPILER_VERSION | sed 's,^\([0-9]*\)\.\([0-9]*\)\.\([0-9]*\).*,\2,'`
QT_GCC_PATCH_VERSION=`echo $COMPILER_VERSION | sed 's,^\([0-9]*\)\.\([0-9]*\)\.\([0-9]*\).*,\3,'`
;;
*.*)
QT_GCC_MAJOR_VERSION=`echo $COMPILER_VERSION | sed 's,^\([0-9]*\)\.\([0-9]*\).*,\1,'`
QT_GCC_MINOR_VERSION=`echo $COMPILER_VERSION | sed 's,^\([0-9]*\)\.\([0-9]*\).*,\2,'`
QT_GCC_PATCH_VERSION=0
;;
esac
case "$COMPILER_VERSION" in
2.95.*)
COMPILER_VERSION="2.95.*"
;;
3.*)
COMPILER_VERSION="3.*"
;;
4.*)
COMPILER_VERSION="4"
;;
*)
;;
esac
[ '!' -z "$COMPILER_VERSION" ] && COMPILER="g++-${COMPILER_VERSION}"
;;
*)
#
;;
esac
# QT_CONFIG can contain the following:
#
# Things that affect the Qt API/ABI:
#
# Options:
# minimal-config small-config medium-config large-config full-config
#
# Different edition modules:
# network canvas table xml opengl sql
#
# Things that do not affect the Qt API/ABI:
# stl
# system-jpeg no-jpeg jpeg
# system-mng no-mng mng
# system-png no-png png
# system-zlib no-zlib zlib
# system-libtiff no-libtiff
# no-gif gif
# debug release
# dll staticlib
#
# nocrosscompiler
# GNUmake
# largefile
# nis
# nas
# tablet
# ipv6
#
# X11 : x11sm xinerama xcursor xfixes xrandr xrender mitshm fontconfig xkb
# Embedded: embedded freetype
#
ALL_OPTIONS=
BUILD_CONFIG=
BUILD_OPTIONS=
# determine the build options
for config_option in $QMAKE_CONFIG $QT_CONFIG; do
SKIP="yes"
case "$config_option" in
*-config)
# take the last *-config setting. this is the highest config being used,
# and is the one that we will use for tagging plugins
BUILD_CONFIG="$config_option"
;;
*) # skip all other options since they don't affect the Qt API/ABI.
;;
esac
if [ "$SKIP" = "no" ]; then
BUILD_OPTIONS="$BUILD_OPTIONS $config_option"
fi
done
# put the options that we are missing into .options
rm -f .options
for opt in `echo $ALL_OPTIONS`; do
SKIP="no"
if echo $BUILD_OPTIONS | grep $opt >/dev/null 2>&1; then
SKIP="yes"
fi
if [ "$SKIP" = "no" ]; then
echo "$opt" >> .options
fi
done
# reconstruct BUILD_OPTIONS with a sorted negative feature list
# (ie. only things that are missing are will be put into the build key)
BUILD_OPTIONS=
if [ -f .options ]; then
for opt in `sort -f .options | uniq`; do
BUILD_OPTIONS="$BUILD_OPTIONS no-$opt"
done
fi
rm -f .options
# QT_NO* defines affect the Qt API (and binary compatibility). they need
# to be included in the build key
for build_option in $D_FLAGS; do
build_option=`echo $build_option | cut -d \" -f 2 -`
case "$build_option" in
QT_NO*)
echo "$build_option" >> .options
;;
*)
# skip all other compiler defines
;;
esac
done
# sort the compile time defines (helps ensure that changes in this configure
# script don't affect the QT_BUILD_KEY generation)
if [ -f .options ]; then
for opt in `sort -f .options | uniq`; do
BUILD_OPTIONS="$BUILD_OPTIONS $opt"
done
fi
rm -f .options
BUILD_OPTIONS="$BUILD_CONFIG $BUILD_OPTIONS"
# extract the operating system from the XPLATFORM
TARGET_OPERATING_SYSTEM=`echo $XPLATFORM | cut -f 2- -d/ | cut -f -1 -d-`
# when cross-compiling, don't include build-host information (build key is target specific)
QT_BUILD_KEY="$CFG_USER_BUILD_KEY $CFG_ARCH $TARGET_OPERATING_SYSTEM $COMPILER $BUILD_OPTIONS"
if [ -n "$QT_NAMESPACE" ]; then
QT_BUILD_KEY="$QT_BUILD_KEY $QT_NAMESPACE"
fi
MAC_NEED_TWO_BUILD_KEYS="no"
if [ "$PLATFORM_MAC" = "yes" -a "$CFG_MAC_COCOA" = "yes" ]; then
QT_BUILD_KEY_CARBON=$QT_BUILD_KEY
TARGET_OPERATING_SYSTEM="$TARGET_OPERATING_SYSTEM-cocoa"
QT_BUILD_KEY_COCOA="$CFG_USER_BUILD_KEY $CFG_ARCH $TARGET_OPERATING_SYSTEM $COMPILER $BUILD_OPTIONS"
if [ "$CFG_MAC_CARBON" = "no" ]; then
QT_BUILD_KEY=$QT_BUILD_KEY_COCOA
else
MAC_NEED_TWO_BUILD_KEYS="yes"
fi
fi
# don't break loading plugins build with an older version of Qt
QT_BUILD_KEY_COMPAT=
if [ "$QT_CROSS_COMPILE" = "no" ]; then
# previous versions of Qt used a build key built from the uname
QT_BUILD_KEY_COMPAT="$CFG_USER_BUILD_KEY $UNAME_MACHINE $UNAME_SYSTEM $COMPILER $BUILD_OPTIONS"
if [ -n "$QT_NAMESPACE" ]; then
QT_BUILD_KEY_COMPAT="$QT_BUILD_KEY_COMPAT $QT_NAMESPACE"
fi
fi
# strip out leading/trailing/extra whitespace
QT_BUILD_KEY=`echo $QT_BUILD_KEY | sed -e "s, *, ,g" -e "s,^ *,," -e "s, *$,,"`
QT_BUILD_KEY_COMPAT=`echo $QT_BUILD_KEY_COMPAT | sed -e "s, *, ,g" -e "s,^ *,," -e "s, *$,,"`
#-------------------------------------------------------------------------------
# part of configuration information goes into qconfig.h
#-------------------------------------------------------------------------------
case "$CFG_QCONFIG" in
full)
echo "/* Everything */" >"$outpath/src/corelib/global/qconfig.h.new"
;;
*)
tmpconfig="$outpath/src/corelib/global/qconfig.h.new"
echo "#ifndef QT_BOOTSTRAPPED" >"$tmpconfig"
cat "$relpath/src/corelib/global/qconfig-$CFG_QCONFIG.h" >>"$tmpconfig"
echo "#endif" >>"$tmpconfig"
;;
esac
cat >>"$outpath/src/corelib/global/qconfig.h.new" <<EOF
#ifndef QT_DLL
#define QT_DLL
#endif
/*License information*/
#define QT_PRODUCT_LICENSEE "$Licensee"
#define QT_PRODUCT_LICENSE "$Edition"
/* Qt Edition */
#ifndef QT_EDITION
# define QT_EDITION $QT_EDITION
#endif
EOF
if [ "$CFG_DEV" = "yes" ]; then
cat >>"$outpath/src/corelib/global/qconfig.h.new" <<EOF
/* Used for example to export symbols for the certain autotests*/
#define QT_BUILD_INTERNAL
EOF
fi
cat >>"$outpath/src/corelib/global/qconfig.h.new" <<EOF
/* Machine byte-order */
#define Q_BIG_ENDIAN 4321
#define Q_LITTLE_ENDIAN 1234
EOF
echo "#ifdef QT_BOOTSTRAPPED" >>"$outpath/src/corelib/global/qconfig.h.new"
if [ "$CFG_HOST_ENDIAN" = "auto" ]; then
cat >>"$outpath/src/corelib/global/qconfig.h.new" <<EOF
#if defined(__BIG_ENDIAN__)
# define Q_BYTE_ORDER Q_BIG_ENDIAN
#elif defined(__LITTLE_ENDIAN__)
# define Q_BYTE_ORDER Q_LITTLE_ENDIAN
#else
# error "Unable to determine byte order!"
#endif
EOF
else
echo "#define Q_BYTE_ORDER $CFG_HOST_ENDIAN" >>"$outpath/src/corelib/global/qconfig.h.new"
fi
echo "#else" >>"$outpath/src/corelib/global/qconfig.h.new"
if [ "$CFG_ENDIAN" = "auto" ]; then
cat >>"$outpath/src/corelib/global/qconfig.h.new" <<EOF
#if defined(__BIG_ENDIAN__)
# define Q_BYTE_ORDER Q_BIG_ENDIAN
#elif defined(__LITTLE_ENDIAN__)
# define Q_BYTE_ORDER Q_LITTLE_ENDIAN
#else
# error "Unable to determine byte order!"
#endif
EOF
else
echo "#define Q_BYTE_ORDER $CFG_ENDIAN" >>"$outpath/src/corelib/global/qconfig.h.new"
fi
echo "#endif" >>"$outpath/src/corelib/global/qconfig.h.new"
CFG_ARCH_STR=`echo $CFG_ARCH | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
CFG_HOST_ARCH_STR=`echo $CFG_HOST_ARCH | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
cat >>"$outpath/src/corelib/global/qconfig.h.new" <<EOF
# define QT_ARCH_${CFG_ARCH_STR}
EOF
echo '/* Compile time features */' >>"$outpath/src/corelib/global/qconfig.h.new"
[ '!' -z "$LicenseKeyExt" ] && echo "#define QT_PRODUCT_LICENSEKEY \"$LicenseKeyExt\"" >>"$outpath/src/corelib/global/qconfig.h.new"
if [ "$CFG_LARGEFILE" = "yes" ]; then
echo "#define QT_LARGEFILE_SUPPORT 64" >>"$outpath/src/corelib/global/qconfig.h.new"
fi
# if both carbon and cocoa are specified, enable the autodetection code.
if [ "$CFG_MAC_COCOA" = "yes" -a "$CFG_MAC_CARBON" = "yes" ]; then
echo "#define AUTODETECT_COCOA 1" >>"$outpath/src/corelib/global/qconfig.h.new"
elif [ "$CFG_MAC_COCOA" = "yes" ]; then
echo "#define QT_MAC_USE_COCOA 1" >>"$outpath/src/corelib/global/qconfig.h.new"
fi
if [ "$CFG_FRAMEWORK" = "yes" ]; then
echo "#define QT_MAC_FRAMEWORK_BUILD" >>"$outpath/src/corelib/global/qconfig.h.new"
fi
echo "" >>"$outpath/src/corelib/global/qconfig.h.new"
if [ "${CFG_USE_FLOATMATH}" = "yes" ]; then
QCONFIG_FLAGS="${QCONFIG_FLAGS} QT_USE_MATH_H_FLOATS"
fi
# Add turned on SQL drivers
for DRIVER in $CFG_SQL_AVAILABLE; do
eval "VAL=\$CFG_SQL_$DRIVER"
case "$VAL" in
qt)
ONDRIVER=`echo $DRIVER | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
QCONFIG_FLAGS="$QCONFIG_FLAGS QT_SQL_$ONDRIVER"
SQL_DRIVERS="$SQL_DRIVERS $DRIVER"
;;
plugin)
SQL_PLUGINS="$SQL_PLUGINS $DRIVER"
;;
esac
done
#set sql_drivers for Symbian building
if [ "$XPLATFORM"="symbian-sbsv2" -a -z "$SQL_DRIVERS" ]; then
SQL_DRIVERS=sqlite
fi
QMakeVar set sql-drivers "$SQL_DRIVERS"
QMakeVar set sql-plugins "$SQL_PLUGINS"
# Add other configuration options to the qconfig.h file
[ "$CFG_GIF" = "yes" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_BUILTIN_GIF_READER=1"
[ "$CFG_TIFF" != "yes" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_IMAGEFORMAT_TIFF"
[ "$CFG_PNG" != "yes" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_IMAGEFORMAT_PNG"
[ "$CFG_JPEG" != "yes" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_IMAGEFORMAT_JPEG"
[ "$CFG_MNG" != "yes" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_IMAGEFORMAT_MNG"
[ "$CFG_ZLIB" != "yes" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_ZLIB"
[ "$CFG_EXCEPTIONS" = "no" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_EXCEPTIONS"
[ "$CFG_IPV6" = "no" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_IPV6"
[ "$CFG_DBUS" = "no" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_DBUS"
if [ "$PLATFORM_QWS" != "yes" ]; then
[ "$CFG_GRAPHICS_SYSTEM" = "raster" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_GRAPHICSSYSTEM_RASTER"
[ "$CFG_GRAPHICS_SYSTEM" = "opengl" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_GRAPHICSSYSTEM_OPENGL"
[ "$CFG_GRAPHICS_SYSTEM" = "openvg" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_GRAPHICSSYSTEM_OPENVG"
fi
# Configuration flags only for Symbian
QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_CONCURRENT"
QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_QFUTURE"
QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_CRASHHANDLER"
QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_PRINTER"
QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_SYSTEMTRAYICON"
# X11/Unix/Mac only configs
[ "$CFG_GSTREAMER" != "yes" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_GSTREAMER"
[ "$CFG_QGTKSTYLE" != "yes" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_STYLE_GTK"
[ "$CFG_CLOCK_MONOTONIC" = "no" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_CLOCK_MONOTONIC"
[ "$CFG_MREMAP" = "no" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_MREMAP"
[ "$CFG_GETADDRINFO" = "no" ]&& QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_GETADDRINFO"
[ "$CFG_IPV6IFNAME" = "no" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_IPV6IFNAME"
[ "$CFG_GETIFADDRS" = "no" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_GETIFADDRS"
[ "$CFG_NAS" = "no" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_NAS"
[ "$CFG_NIS" = "no" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_NIS"
[ "$CFG_OPENSSL" = "no" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_OPENSSL"
[ "$CFG_OPENSSL" = "linked" ]&& QCONFIG_FLAGS="$QCONFIG_FLAGS QT_LINKED_OPENSSL"
[ "$CFG_SM" = "no" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_SESSIONMANAGER"
[ "$CFG_XCURSOR" = "no" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_XCURSOR"
[ "$CFG_XFIXES" = "no" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_XFIXES"
[ "$CFG_FONTCONFIG" = "no" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_FONTCONFIG"
[ "$CFG_XINERAMA" = "no" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_XINERAMA"
[ "$CFG_XKB" = "no" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_XKB"
[ "$CFG_XRANDR" = "no" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_XRANDR"
[ "$CFG_XRENDER" = "no" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_XRENDER"
[ "$CFG_MITSHM" = "no" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_MITSHM"
[ "$CFG_XSHAPE" = "no" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_SHAPE"
[ "$CFG_XSYNC" = "no" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_XSYNC"
[ "$CFG_XINPUT" = "no" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_XINPUT QT_NO_TABLET"
[ "$CFG_XCURSOR" = "runtime" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_RUNTIME_XCURSOR"
[ "$CFG_XINERAMA" = "runtime" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_RUNTIME_XINERAMA"
[ "$CFG_XFIXES" = "runtime" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_RUNTIME_XFIXES"
[ "$CFG_XRANDR" = "runtime" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_RUNTIME_XRANDR"
[ "$CFG_XINPUT" = "runtime" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_RUNTIME_XINPUT"
[ "$CFG_ALSA" = "no" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_ALSA"
#Symbian only config
echo CFG_QWS_FREETYPE $CFG_QWS_FREETYPE
[ "$CFG_QWS_FREETYPE" = "no" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_FREETYPE"
# sort QCONFIG_FLAGS for neatness if we can
[ '!' -z "$AWK" ] && QCONFIG_FLAGS=`echo $QCONFIG_FLAGS | $AWK '{ gsub(" ", "\n"); print }' | sort | uniq`
QCONFIG_FLAGS=`echo $QCONFIG_FLAGS`
if [ -n "$QCONFIG_FLAGS" ]; then
for cfg in $QCONFIG_FLAGS; do
cfgd=`echo $cfg | sed 's/=.*$//'` # trim pushed 'Foo=Bar' defines
cfg=`echo $cfg | sed 's/=/ /'` # turn first '=' into a space
# figure out define logic, so we can output the correct
# ifdefs to override the global defines in a project
cfgdNeg=
if [ true ] && echo "$cfgd" | grep 'QT_NO_' >/dev/null 2>&1; then
# QT_NO_option can be forcefully turned on by QT_option
cfgdNeg=`echo $cfgd | sed "s,QT_NO_,QT_,"`
elif [ true ] && echo "$cfgd" | grep 'QT_' >/dev/null 2>&1; then
# QT_option can be forcefully turned off by QT_NO_option
cfgdNeg=`echo $cfgd | sed "s,QT_,QT_NO_,"`
fi
if [ -z $cfgdNeg ]; then
cat >>"$outpath/src/corelib/global/qconfig.h.new" << EOF
#ifndef $cfgd
# define $cfg
#endif
EOF
else
cat >>"$outpath/src/corelib/global/qconfig.h.new" << EOF
#if defined($cfgd) && defined($cfgdNeg)
# undef $cfgd
#elif !defined($cfgd) && !defined($cfgdNeg)
# define $cfg
#endif
EOF
fi
done
fi
if [ "$CFG_REDUCE_EXPORTS" = "yes" ]; then
cat >>"$outpath/src/corelib/global/qconfig.h.new" << EOF
#define QT_VISIBILITY_AVAILABLE
EOF
fi
if [ "$CFG_CUPS" = "no" ]; then
echo "#define QT_NO_CUPS" >>"$outpath/src/corelib/global/qconfig.h.new"
fi
if [ "$CFG_ICONV" = "no" ]; then
echo "#define QT_NO_ICONV" >>"$outpath/src/corelib/global/qconfig.h.new"
fi
if [ "$CFG_GLIB" = "no" ]; then
echo "#define QT_NO_GLIB" >>"$outpath/src/corelib/global/qconfig.h.new"
fi
if [ "$CFG_INOTIFY" = "no" ]; then
echo "#define QT_NO_INOTIFY" >>"$outpath/src/corelib/global/qconfig.h.new"
fi
if [ "$CFG_SXE" = "no" ]; then
echo "#define QT_NO_SXE" >>"$outpath/src/corelib/global/qconfig.h.new"
fi
# avoid unecessary rebuilds by copying only if qconfig.h has changed
if cmp -s "$outpath/src/corelib/global/qconfig.h" "$outpath/src/corelib/global/qconfig.h.new"; then
rm -f "$outpath/src/corelib/global/qconfig.h.new"
else
[ -f "$outpath/src/corelib/global/qconfig.h" ] && chmod +w "$outpath/src/corelib/global/qconfig.h"
mv "$outpath/src/corelib/global/qconfig.h.new" "$outpath/src/corelib/global/qconfig.h"
chmod -w "$outpath/src/corelib/global/qconfig.h"
for conf in "$outpath/include/QtCore/qconfig.h" "$outpath/include/Qt/qconfig.h"; do
cp -f "$outpath/src/corelib/global/qconfig.h" "$conf"
done
fi
#-------------------------------------------------------------------------------
# save configuration into qconfig.pri
#-------------------------------------------------------------------------------
QTCONFIG="$outpath/mkspecs/qconfig.pri"
[ -f "$QTCONFIG.tmp" ] && rm -f "$QTCONFIG.tmp"
if [ "$CFG_DEBUG" = "yes" ]; then
QTCONFIG_CONFIG="$QTCONFIG_CONFIG debug"
if [ "$CFG_DEBUG_RELEASE" = "yes" ]; then
QT_CONFIG="$QT_CONFIG release"
fi
QT_CONFIG="$QT_CONFIG debug"
elif [ "$CFG_DEBUG" = "no" ]; then
QTCONFIG_CONFIG="$QTCONFIG_CONFIG release"
if [ "$CFG_DEBUG_RELEASE" = "yes" ]; then
QT_CONFIG="$QT_CONFIG debug"
fi
QT_CONFIG="$QT_CONFIG release"
fi
if [ "$CFG_STL" = "yes" ]; then
QTCONFIG_CONFIG="$QTCONFIG_CONFIG stl"
fi
if [ "$CFG_S60" = "yes" ]; then
QT_CONFIG="$QT_CONFIG s60"
fi
if [ "$CFG_SHARED" = "yes" ]; then
QTCONFIG_CONFIG="$QTCONFIG_CONFIG shared"
else
QTCONFIG_CONFIG="$QTCONFIG_CONFIG static"
fi
if [ "$CFG_RTTI" = "yes" ]; then
QTCONFIG_CONFIG="$QTCONFIG_CONFIG rtti"
fi
if [ "$CFG_DEV" = "yes" ]; then
QT_CONFIG="$QT_CONFIG private_tests"
fi
if [ "$CFG_NATIVE_GESTURES" = "yes" ]; then
QT_CONFIG="$QT_CONFIG native-gestures"
fi
# Make the application arch follow the Qt arch for single arch builds.
# (for multiple-arch builds, set CONFIG manually in the application .pro file)
if [ `echo "$CFG_MAC_ARCHS" | wc -w` -eq 1 ]; then
QTCONFIG_CONFIG="$QTCONFIG_CONFIG $CFG_MAC_ARCHS"
fi
cat >>"$QTCONFIG.tmp" <<EOF
#configuration
CONFIG += $QTCONFIG_CONFIG
QT_ARCH = $CFG_ARCH
QT_EDITION = $Edition
QT_CONFIG += $QT_CONFIG
QMAKE_CXXFLAGS.ARMCC += --fpu softvfp
#versioning
QT_VERSION = $QT_VERSION
QT_MAJOR_VERSION = $QT_MAJOR_VERSION
QT_MINOR_VERSION = $QT_MINOR_VERSION
QT_PATCH_VERSION = $QT_PATCH_VERSION
#namespaces
QT_LIBINFIX = $QT_LIBINFIX
QT_NAMESPACE = $QT_NAMESPACE
QT_NAMESPACE_MAC_CRC = $QT_NAMESPACE_MAC_CRC
EOF
if [ "$CFG_RPATH" = "yes" ]; then
echo "QMAKE_RPATHDIR += \"$QT_INSTALL_LIBS\"" >> "$QTCONFIG.tmp"
fi
if [ -n "$QT_GCC_MAJOR_VERSION" ]; then
echo "QT_GCC_MAJOR_VERSION = $QT_GCC_MAJOR_VERSION" >> "$QTCONFIG.tmp"
echo "QT_GCC_MINOR_VERSION = $QT_GCC_MINOR_VERSION" >> "$QTCONFIG.tmp"
echo "QT_GCC_PATCH_VERSION = $QT_GCC_PATCH_VERSION" >> "$QTCONFIG.tmp"
fi
# replace qconfig.pri if it differs from the newly created temp file
if cmp -s "$QTCONFIG.tmp" "$QTCONFIG"; then
rm -f "$QTCONFIG.tmp"
else
mv -f "$QTCONFIG.tmp" "$QTCONFIG"
fi
#-------------------------------------------------------------------------------
# save configuration into .qmake.cache
#-------------------------------------------------------------------------------
CACHEFILE="$outpath/.qmake.cache"
[ -f "$CACHEFILE.tmp" ] && rm -f "$CACHEFILE.tmp"
cat >>"$CACHEFILE.tmp" <<EOF
CONFIG += $QMAKE_CONFIG incremental create_prl link_prl depend_includepath QTDIR_build
QT_SOURCE_TREE = \$\$quote($relpath)
QT_BUILD_TREE = \$\$quote($outpath)
QT_BUILD_PARTS = $CFG_BUILD_PARTS
QMAKE_ABSOLUTE_SOURCE_ROOT = \$\$QT_SOURCE_TREE
QMAKE_MOC_SRC = \$\$QT_BUILD_TREE/src/moc
ARCH = $CFG_ARCH
#local paths that cannot be queried from the QT_INSTALL_* properties while building QTDIR
QMAKE_MOC = \$\$QT_BUILD_TREE/bin/moc
QMAKE_UIC = \$\$QT_BUILD_TREE/bin/uic
QMAKE_UIC3 = \$\$QT_BUILD_TREE/bin/uic3
QMAKE_RCC = \$\$QT_BUILD_TREE/bin/rcc
QMAKE_QDBUSXML2CPP = \$\$QT_BUILD_TREE/bin/qdbusxml2cpp
QMAKE_INCDIR_QT = \$\$QT_BUILD_TREE/include
QMAKE_LIBDIR_QT = \$\$QT_BUILD_TREE/lib
EOF
# Ensure we can link to uninistalled libraries
if [ -n "$QT_CFLAGS_PSQL" ]; then
echo "QT_CFLAGS_PSQL = $QT_CFLAGS_PSQL" >> "$CACHEFILE.tmp"
fi
if [ -n "$QT_LFLAGS_PSQL" ]; then
echo "QT_LFLAGS_PSQL = $QT_LFLAGS_PSQL" >> "$CACHEFILE.tmp"
fi
if [ -n "$QT_CFLAGS_MYSQL" ]; then
echo "QT_CFLAGS_MYSQL = $QT_CFLAGS_MYSQL" >> "$CACHEFILE.tmp"
fi
if [ -n "$QT_LFLAGS_MYSQL" ]; then
echo "QT_LFLAGS_MYSQL = $QT_LFLAGS_MYSQL" >> "$CACHEFILE.tmp"
fi
if [ -n "$QT_CFLAGS_SQLITE" ]; then
echo "QT_CFLAGS_SQLITE = $QT_CFLAGS_SQLITE" >> "$CACHEFILE.tmp"
fi
if [ -n "$QT_LFLAGS_SQLITE" ]; then
echo "QT_LFLAGS_SQLITE = $QT_LFLAGS_SQLITE" >> "$CACHEFILE.tmp"
fi
if [ -n "$QT_LFLAGS_ODBC" ]; then
echo "QT_LFLAGS_ODBC = $QT_LFLAGS_ODBC" >> "$CACHEFILE.tmp"
fi
if [ "$QT_EDITION" != "QT_EDITION_OPENSOURCE" ]; then
echo "DEFINES *= QT_EDITION=QT_EDITION_DESKTOP" >> "$CACHEFILE.tmp"
fi
#dump in the OPENSSL_LIBS info
if [ '!' -z "$OPENSSL_LIBS" ]; then
echo "OPENSSL_LIBS = $OPENSSL_LIBS" >> "$CACHEFILE.tmp"
elif [ "$CFG_OPENSSL" = "linked" ]; then
echo "OPENSSL_LIBS = -lssl -lcrypto" >> "$CACHEFILE.tmp"
fi
#dump in the SDK info
if [ '!' -z "$CFG_SDK" ]; then
echo "QMAKE_MAC_SDK = $CFG_SDK" >> "$CACHEFILE.tmp"
fi
# mac gcc -Xarch support
if [ "$CFG_MAC_XARCH" = "no" ]; then
echo "QMAKE_MAC_XARCH = no" >> "$CACHEFILE.tmp"
fi
#dump the qmake spec
if [ -d "$outpath/mkspecs/$XPLATFORM" ]; then
echo "QMAKESPEC = \$\$QT_BUILD_TREE/mkspecs/$XPLATFORM" >> "$CACHEFILE.tmp"
else
echo "QMAKESPEC = $XPLATFORM" >> "$CACHEFILE.tmp"
fi
# cmdline args
cat "$QMAKE_VARS_FILE" >> "$CACHEFILE.tmp"
rm -f "$QMAKE_VARS_FILE" 2>/dev/null
# incrementals
INCREMENTAL=""
[ "$CFG_INCREMENTAL" = "auto" ] && "$WHICH" p4 >/dev/null 2>&1 && [ "$CFG_DEV" = "yes" ] && CFG_INCREMENTAL="yes"
if [ "$CFG_INCREMENTAL" = "yes" ]; then
find "$relpath" -perm u+w -mtime -3 | grep 'cpp$' | while read f; do
# don't need to worry about generated files
[ -r `echo $f | sed "s,cpp$,ui,"` ] && continue
basename "$f" | grep '^moc_' >/dev/null 2>&1 && continue
# done
INCREMENTAL="$INCREMENTAL `basename \"$f\" | sed 's,.cpp,.o,'`"
done
[ '!' -z "$INCREMENTAL" ] && echo "QMAKE_INCREMENTAL += $INCREMENTAL" >> "$CACHEFILE.tmp"
[ -r "$outpath/.qmake.incremental" ] && echo "include($outpath/.qmake.incremental)" >> "$CACHEFILE.tmp"
fi
# replace .qmake.cache if it differs from the newly created temp file
if cmp -s "$CACHEFILE.tmp" "$CACHEFILE"; then
rm -f "$CACHEFILE.tmp"
else
mv -f "$CACHEFILE.tmp" "$CACHEFILE"
fi
#-------------------------------------------------------------------------------
# give feedback on configuration
#-------------------------------------------------------------------------------
case "$COMPILER" in
g++*)
if [ "$CFG_EXCEPTIONS" != "no" ]; then
cat <<EOF
This target is using the GNU C++ compiler ($PLATFORM).
Recent versions of this compiler automatically include code for
exceptions, which increase both the size of the Qt libraries and
the amount of memory taken by your applications.
You may choose to re-run `basename $0` with the -no-exceptions
option to compile Qt without exceptions. This is completely binary
compatible, and existing applications will continue to work.
EOF
fi
;;
cc*)
case "$PLATFORM" in
irix-cc*)
if [ "$CFG_EXCEPTIONS" != "no" ]; then
cat <<EOF
This target is using the MIPSpro C++ compiler ($PLATFORM).
You may choose to re-run `basename $0` with the -no-exceptions
option to compile Qt without exceptions. This will make the
size of the Qt library smaller and reduce the amount of memory
taken by your applications.
EOF
fi
;;
*) ;;
esac
;;
*) ;;
esac
if [ "$PLATFORM_MAC" = "yes" ] && [ "$CFG_MAC_DWARF2" = "no" ] && [ "$CFG_WEBKIT" = "yes" ] && [ "$CFG_DEBUG_RELEASE" = "yes" ]; then
cat <<EOF
WARNING: DWARF2 debug symbols are not enabled. Linking webkit
in debug mode will run out of memory on systems with 2GB or less.
Install Xcode 2.4.1 or higher to enable DWARF2, or configure with
-no-webkit or -release to skip webkit debug.
EOF
fi
echo
if [ "$XPLATFORM" = "$PLATFORM" ]; then
echo "Build type: $PLATFORM"
else
echo "Building on: $PLATFORM"
echo "Building for: $XPLATFORM"
fi
if [ "$PLATFORM_MAC" = "yes" ]; then
echo "Architecture: $CFG_ARCH ($CFG_MAC_ARCHS )"
else
echo "Architecture: $CFG_ARCH"
fi
if [ "$PLATFORM_QWS" = "yes" ]; then
echo "Host architecture: $CFG_HOST_ARCH"
fi
if [ "$PLATFORM_MAC" = "yes" ]; then
if [ "$CFG_MAC_COCOA" = "yes" ]; then
if [ "$CFG_MAC_CARBON" = "yes" ]; then
echo "Using framework: Carbon for 32-bit, Cocoa for 64-bit"
else
echo "Using framework: Cocoa"
fi
else
echo "Using framework: Carbon"
fi
fi
if [ -n "$PLATFORM_NOTES" ]; then
echo "Platform notes:"
echo "$PLATFORM_NOTES"
else
echo
fi
if [ "$OPT_VERBOSE" = "yes" ]; then
if echo '\c' | grep '\c' >/dev/null; then
echo -n "qmake vars .......... "
else
echo "qmake vars .......... \c"
fi
cat "$QMAKE_VARS_FILE" | tr '\n' ' '
echo "qmake switches ...... $QMAKE_SWITCHES"
fi
[ "$CFG_INCREMENTAL" = "yes" ] && [ '!' -z "$INCREMENTAL" ] && echo "Incremental ......... $INCREMENTAL"
echo "Build ............... $CFG_BUILD_PARTS"
echo "Configuration ....... $QMAKE_CONFIG $QT_CONFIG"
if [ "$CFG_DEBUG_RELEASE" = "yes" ]; then
echo "Debug ............... yes (combined)"
if [ "$CFG_DEBUG" = "yes" ]; then
echo "Default Link ........ debug"
else
echo "Default Link ........ release"
fi
else
echo "Debug ............... $CFG_DEBUG"
fi
echo "Qt 3 compatibility .. $CFG_QT3SUPPORT"
[ "$CFG_DBUS" = "no" ] && echo "QtDBus module ....... no"
[ "$CFG_DBUS" = "yes" ] && echo "QtDBus module ....... yes (run-time)"
[ "$CFG_DBUS" = "linked" ] && echo "QtDBus module ....... yes (linked)"
echo "QtConcurrent code.... $CFG_CONCURRENT"
echo "QtScript module ..... $CFG_SCRIPT"
echo "QtScriptTools module $CFG_SCRIPTTOOLS"
echo "QtXmlPatterns module $CFG_XMLPATTERNS"
echo "Phonon module ....... $CFG_PHONON"
echo "Multimedia module ... $CFG_MULTIMEDIA"
echo "SVG module .......... $CFG_SVG"
echo "WebKit module ....... $CFG_WEBKIT"
if [ "$CFG_WEBKIT" = "yes" ]; then
if [ "$CFG_JAVASCRIPTCORE_JIT" = "auto" ]; then
echo "JavaScriptCore JIT .. To be decided by JavaScriptCore"
else
echo "JavaScriptCore JIT .. $CFG_JAVASCRIPTCORE_JIT"
fi
fi
echo "Declarative module .. $CFG_DECLARATIVE"
echo "STL support ......... $CFG_STL"
echo "PCH support ......... $CFG_PRECOMPILE"
echo "MMX/3DNOW/SSE/SSE2.. ${CFG_MMX}/${CFG_3DNOW}/${CFG_SSE}/${CFG_SSE2}"
if [ "${CFG_ARCH}" = "arm" ]; then
echo "iWMMXt support ...... ${CFG_IWMMXT}"
fi
[ "${PLATFORM_QWS}" != "yes" ] && echo "Graphics System ..... $CFG_GRAPHICS_SYSTEM"
echo "IPv6 support ........ $CFG_IPV6"
echo "IPv6 ifname support . $CFG_IPV6IFNAME"
echo "getaddrinfo support . $CFG_GETADDRINFO"
echo "getifaddrs support .. $CFG_GETIFADDRS"
echo "Accessibility ....... $CFG_ACCESSIBILITY"
echo "NIS support ......... $CFG_NIS"
echo "CUPS support ........ $CFG_CUPS"
echo "Iconv support ....... $CFG_ICONV"
echo "Glib support ........ $CFG_GLIB"
echo "GStreamer support ... $CFG_GSTREAMER"
echo "Large File support .. $CFG_LARGEFILE"
echo "GIF support ......... $CFG_GIF"
if [ "$CFG_TIFF" = "no" ]; then
echo "TIFF support ........ $CFG_TIFF"
else
echo "TIFF support ........ $CFG_TIFF ($CFG_LIBTIFF)"
fi
if [ "$CFG_JPEG" = "no" ]; then
echo "JPEG support ........ $CFG_JPEG"
else
echo "JPEG support ........ $CFG_JPEG ($CFG_LIBJPEG)"
fi
if [ "$CFG_PNG" = "no" ]; then
echo "PNG support ......... $CFG_PNG"
else
echo "PNG support ......... $CFG_PNG ($CFG_LIBPNG)"
fi
if [ "$CFG_MNG" = "no" ]; then
echo "MNG support ......... $CFG_MNG"
else
echo "MNG support ......... $CFG_MNG ($CFG_LIBMNG)"
fi
echo "zlib support ........ $CFG_ZLIB"
echo "Session management .. $CFG_SM"
if [ "$PLATFORM_QWS" = "yes" ]; then
echo "Embedded support .... $CFG_EMBEDDED"
if [ "$CFG_QWS_FREETYPE" = "auto" ]; then
echo "Freetype2 support ... $CFG_QWS_FREETYPE ($CFG_LIBFREETYPE)"
else
echo "Freetype2 support ... $CFG_QWS_FREETYPE"
fi
# Normalize the decoration output first
CFG_GFX_ON=`echo ${CFG_GFX_ON}`
CFG_GFX_PLUGIN=`echo ${CFG_GFX_PLUGIN}`
echo "Graphics (qt) ....... ${CFG_GFX_ON}"
echo "Graphics (plugin) ... ${CFG_GFX_PLUGIN}"
CFG_DECORATION_ON=`echo ${CFG_DECORATION_ON}`
CFG_DECORATION_PLUGIN=`echo ${CFG_DECORATION_PLUGIN}`
echo "Decorations (qt) .... $CFG_DECORATION_ON"
echo "Decorations (plugin) $CFG_DECORATION_PLUGIN"
CFG_KBD_ON=`echo ${CFG_KBD_ON}`
CFG_KBD_PLUGIN=`echo ${CFG_KBD_PLUGIN}`
echo "Keyboard driver (qt). ${CFG_KBD_ON}"
echo "Keyboard driver (plugin) ${CFG_KBD_PLUGIN}"
CFG_MOUSE_ON=`echo ${CFG_MOUSE_ON}`
CFG_MOUSE_PLUGIN=`echo ${CFG_MOUSE_PLUGIN}`
echo "Mouse driver (qt) ... $CFG_MOUSE_ON"
echo "Mouse driver (plugin) $CFG_MOUSE_PLUGIN"
fi
if [ "$CFG_OPENGL" = "desktop" ]; then
echo "OpenGL support ...... yes (Desktop OpenGL)"
elif [ "$CFG_OPENGL" = "es1" ]; then
echo "OpenGL support ...... yes (OpenGL ES 1.x Common profile)"
elif [ "$CFG_OPENGL" = "es1cl" ]; then
echo "OpenGL support ...... yes (OpenGL ES 1.x Common Lite profile)"
elif [ "$CFG_OPENGL" = "es2" ]; then
echo "OpenGL support ...... yes (OpenGL ES 2.x)"
else
echo "OpenGL support ...... no"
fi
if [ "$CFG_EGL" != "no" ]; then
if [ "$CFG_EGL_GLES_INCLUDES" != "no" ]; then
echo "EGL support ......... yes <GLES/egl.h>"
else
echo "EGL support ......... yes <EGL/egl.h>"
fi
fi
if [ "$CFG_OPENVG" ]; then
if [ "$CFG_OPENVG_SHIVA" = "yes" ]; then
echo "OpenVG support ...... ShivaVG"
else
echo "OpenVG support ...... $CFG_OPENVG"
fi
fi
if [ "$PLATFORM_X11" = "yes" ]; then
echo "NAS sound support ... $CFG_NAS"
echo "XShape support ...... $CFG_XSHAPE"
echo "XSync support ....... $CFG_XSYNC"
echo "Xinerama support .... $CFG_XINERAMA"
echo "Xcursor support ..... $CFG_XCURSOR"
echo "Xfixes support ...... $CFG_XFIXES"
echo "Xrandr support ...... $CFG_XRANDR"
echo "Xrender support ..... $CFG_XRENDER"
echo "Xi support .......... $CFG_XINPUT"
echo "MIT-SHM support ..... $CFG_MITSHM"
echo "FontConfig support .. $CFG_FONTCONFIG"
echo "XKB Support ......... $CFG_XKB"
echo "immodule support .... $CFG_IM"
echo "GTK theme support ... $CFG_QGTKSTYLE"
fi
[ "$CFG_SQL_mysql" != "no" ] && echo "MySQL support ....... $CFG_SQL_mysql"
[ "$CFG_SQL_psql" != "no" ] && echo "PostgreSQL support .. $CFG_SQL_psql"
[ "$CFG_SQL_odbc" != "no" ] && echo "ODBC support ........ $CFG_SQL_odbc"
[ "$CFG_SQL_oci" != "no" ] && echo "OCI support ......... $CFG_SQL_oci"
[ "$CFG_SQL_tds" != "no" ] && echo "TDS support ......... $CFG_SQL_tds"
[ "$CFG_SQL_db2" != "no" ] && echo "DB2 support ......... $CFG_SQL_db2"
[ "$CFG_SQL_ibase" != "no" ] && echo "InterBase support ... $CFG_SQL_ibase"
[ "$CFG_SQL_sqlite2" != "no" ] && echo "SQLite 2 support .... $CFG_SQL_sqlite2"
[ "$CFG_SQL_sqlite" != "no" ] && echo "SQLite support ...... $CFG_SQL_sqlite ($CFG_SQLITE)"
OPENSSL_LINKAGE=""
if [ "$CFG_OPENSSL" = "yes" ]; then
OPENSSL_LINKAGE="(run-time)"
elif [ "$CFG_OPENSSL" = "linked" ]; then
OPENSSL_LINKAGE="(linked)"
fi
echo "OpenSSL support ..... $CFG_OPENSSL $OPENSSL_LINKAGE"
[ "$CFG_PTMALLOC" != "no" ] && echo "Use ptmalloc ........ $CFG_PTMALLOC"
# complain about not being able to use dynamic plugins if we are using a static build
if [ "$CFG_SHARED" = "no" ]; then
echo
echo "WARNING: Using static linking will disable the use of dynamically"
echo "loaded plugins. Make sure to import all needed static plugins,"
echo "or compile needed modules into the library."
echo
fi
if [ "$CFG_OPENSSL" = "linked" ] && [ "$OPENSSL_LIBS" = "" ]; then
echo
echo "NOTE: When linking against OpenSSL, you can override the default"
echo "library names through OPENSSL_LIBS."
echo "For example:"
echo " ./configure -openssl-linked OPENSSL_LIBS='-L/opt/ssl/lib -lssl -lcrypto'"
echo
fi
if [ "$PLATFORM_MAC" = "yes" ] && [ "$CFG_FRAMEWORK" = "yes" ] && [ "$CFG_DEBUG" = "yes" ] && [ "$CFG_DEBUG_RELEASE" = "no" ]; then
echo
echo "NOTE: Mac OS X frameworks implicitly build debug and release Qt libraries."
echo
fi
echo "alsa support ........ $CFG_ALSA"
echo
sepath=`echo "$relpath" | sed -e 's/\\./\\\\./g'`
PROCS=1
EXEC=""
#-------------------------------------------------------------------------------
# build makefiles based on the configuration
#-------------------------------------------------------------------------------
#: QTPRO for Symbian compilation it is necessary to replace qmake with standard qmake handling
echo "Finding project files. Please wait..."
if [ "$CFG_NOPROCESS" != "yes" ]; then
if [ "$XPLATFORM" != "symbian-sbsv2" ]; then
"$outpath/bin/qmake" -prl -r "${relpath}/projects.pro"
fi
if [ -f "${relpath}/projects.pro" ]; then
echo "parsing projects.pro file and generate make files"
mkfile="${outpath}/Makefile"
[ -f "$mkfile" ] && chmod +w "$mkfile"
QTDIR="$outpath" "$outpath/bin/qmake" -spec "$XQMAKESPEC" "${relpath}/projects.pro"
fi
fi
# .projects -> projects to process
# .projects.1 -> qt and moc
# .projects.2 -> subdirs and libs
# .projects.3 -> the rest
rm -f .projects .projects.1 .projects.2 .projects.3
QMAKE_PROJECTS=`find "$relpath/." -name '*.pro' -print | sed 's-/\./-/-'`
if [ -z "$AWK" ]; then
for p in `echo $QMAKE_PROJECTS`; do
echo "$p" >> .projects
done
else
cat >projects.awk <<EOF
BEGIN {
files = 0
target_file = ""
input_file = ""
first = "./.projects.1.tmp"
second = "./.projects.2.tmp"
third = "./.projects.3.tmp"
}
FNR == 1 {
if ( input_file ) {
if ( ! target_file )
target_file = third
print input_file >target_file
}
matched_target = 0
template_lib = 0
input_file = FILENAME
target_file = ""
}
/^(TARGET.*=)/ {
if ( \$3 == "moc" || \$3 ~ /^Qt/ ) {
target_file = first
matched_target = 1
} else if ( \$3 == "lrelease" || \$3 == "qm_phony_target" ) {
target_file = second
matched_target = 1
}
}
matched_target == 0 && /^(TEMPLATE.*=)/ {
if ( \$3 == "subdirs" )
target_file = second
else if ( \$3 == "lib" )
template_lib = 1
else
target_file = third
}
matched_target == 0 && template_lib == 1 && /^(CONFIG.*=)/ {
if ( \$0 ~ /plugin/ )
target_file = third
else
target_file = second
}
END {
if ( input_file ) {
if ( ! target_file )
target_file = third
print input_file >>target_file
}
}
EOF
rm -f .projects.all
for p in `echo $QMAKE_PROJECTS`; do
echo "$p" >> .projects.all
done
# if you get errors about the length of the command line to awk, change the -l arg
# to split below
split -l 100 .projects.all .projects.all.
for p in .projects.all.*; do
"$AWK" -f projects.awk `cat $p`
[ -f .projects.1.tmp ] && cat .projects.1.tmp >> .projects.1
[ -f .projects.2.tmp ] && cat .projects.2.tmp >> .projects.2
[ -f .projects.3.tmp ] && cat .projects.3.tmp >> .projects.3
rm -f .projects.1.tmp .projects.2.tmp .projects.3.tmp $p
done
rm -f .projects.all* projects.awk
[ -f .projects.1 ] && cat .projects.1 >>.projects
[ -f .projects.2 ] && cat .projects.2 >>.projects
rm -f .projects.1 .projects.2
if [ -f .projects.3 ] && [ "$OPT_FAST" = "no" ]; then
cat .projects.3 >>.projects
rm -f .projects.3
fi
fi
# don't sort Qt and MOC in with the other project files
# also work around a segfaulting uniq(1)
if [ -f .sorted.projects.2 ]; then
sort .sorted.projects.2 > .sorted.projects.2.new
mv -f .sorted.projects.2.new .sorted.projects.2
cat .sorted.projects.2 >> .sorted.projects.1
fi
[ -f .sorted.projects.1 ] && sort .sorted.projects.1 >> .sorted.projects
rm -f .sorted.projects.2 .sorted.projects.1
NORM_PROJECTS=0
FAST_PROJECTS=0
if [ -f .projects ]; then
uniq .projects >.tmp
mv -f .tmp .projects
NORM_PROJECTS=`cat .projects | wc -l | sed -e "s, ,,g"`
fi
if [ -f .projects.3 ]; then
uniq .projects.3 >.tmp
mv -f .tmp .projects.3
FAST_PROJECTS=`cat .projects.3 | wc -l | sed -e "s, ,,g"`
fi
echo " `expr $NORM_PROJECTS + $FAST_PROJECTS` projects found."
echo
PART_ROOTS=
for part in $CFG_BUILD_PARTS; do
case "$part" in
tools) PART_ROOTS="$PART_ROOTS tools" ;;
libs) PART_ROOTS="$PART_ROOTS src" ;;
translations) PART_ROOTS="$PART_ROOTS tools/linguist/lrelease" ;;
examples) PART_ROOTS="$PART_ROOTS examples demos" ;;
*) ;;
esac
done
if [ "$CFG_DEV" = "yes" ]; then
PART_ROOTS="$PART_ROOTS tests"
fi
echo "Creating makefiles. Please wait..."
for file in .projects .projects.3; do
[ '!' -f "$file" ] && continue
for a in `cat $file`; do
IN_ROOT=no
for r in $PART_ROOTS; do
if echo "$a" | grep "^$r" >/dev/null 2>&1 || echo "$a" | grep "^$relpath/$r" >/dev/null 2>&1; then
IN_ROOT=yes
break
fi
done
[ "$IN_ROOT" = "no" ] && continue
case $a in
*winmain/winmain.pro) continue ;;
*s60main/s60main.pro) if [ "$PLATFORM_SYMBIAN" != "yes" -o "$CFG_NOPROCESS" = "yes" ]; then
continue
fi;;
*examples/activeqt/*) continue ;;
*/qmake/qmake.pro) continue ;;
*tools*|*tools/bootstrap*|*tools/moc*|*tools/rcc*|*tools/uic*|*linguist/lrelease*) SPEC=$QMAKESPEC ;;
*) if [ "$CFG_NOPROCESS" = "yes" ]; then
continue
else
SPEC=$XQMAKESPEC
fi;;
esac
dir=`dirname "$a" | sed -e "s;$sepath;.;g"`
test -d "$dir" || mkdir -p "$dir"
OUTDIR="$outpath/$dir"
if [ -f "${OUTDIR}/Makefile" ] && [ "$OPT_FAST" = "yes" ]; then
# fast configure - the makefile exists, skip it
# since the makefile exists, it was generated by qmake, which means we
# can skip it, since qmake has a rule to regenerate the makefile if the .pro
# file changes...
[ "$OPT_VERBOSE" = "yes" ] && echo " skipping $a"
continue;
fi
QMAKE_SPEC_ARGS="-spec $SPEC"
if echo '\c' | grep '\c' >/dev/null; then
echo -n " for $a"
else
echo " for $a\c"
fi
QMAKE="$outpath/bin/qmake"
QMAKE_ARGS="$QMAKE_SWITCHES $QMAKE_SPEC_ARGS"
if [ "$file" = ".projects.3" ]; then
if echo '\c' | grep '\c' >/dev/null; then
echo -n " (fast)"
else
echo " (fast)\c"
fi
echo
cat >"${OUTDIR}/Makefile" <<EOF
# ${OUTDIR}/Makefile: generated by configure
#
# WARNING: This makefile will be replaced with a real makefile.
# All changes made to this file will be lost.
EOF
[ "$CFG_DEBUG_RELEASE" = "no" ] && echo "first_target: first" >>${OUTDIR}/Makefile
cat >>"${OUTDIR}/Makefile" <<EOF
QMAKE = "$QMAKE"
all clean install qmake first Makefile: FORCE
\$(QMAKE) $QMAKE_ARGS -o "$OUTDIR" "$a"
cd "$OUTDIR"
\$(MAKE) \$@
FORCE:
EOF
else
if [ "$OPT_VERBOSE" = "yes" ]; then
echo " (`basename $SPEC`)"
echo "$QMAKE" $QMAKE_ARGS -o "$OUTDIR" "$a"
else
echo
fi
[ -f "${OUTDIR}/Makefile" ] && chmod +w "${OUTDIR}/Makefile"
QTDIR="$outpath" "$QMAKE" $QMAKE_ARGS -o "$OUTDIR" "$a"
echo "$QTDIR" "value"
fi
done
done
rm -f .projects .projects.3
#-------------------------------------------------------------------------------
# XShape is important, DnD in the Designer doens't work without it
#-------------------------------------------------------------------------------
if [ "$PLATFORM_X11" = "yes" ] && [ "$CFG_XSHAPE" = "no" ]; then
cat <<EOF
NOTICE: Qt will not be built with XShape support.
As a result, drag-and-drop in the Qt Designer will NOT
work. We recommend that you enable XShape support by passing
the -xshape switch to $0.
EOF
fi
#-------------------------------------------------------------------------------
# check for platforms that we don't yet know about
#-------------------------------------------------------------------------------
if [ "$CFG_ARCH" = "generic" ]; then
cat <<EOF
NOTICE: Atomic operations are not yet supported for this
architecture.
Qt will use the 'generic' architecture instead, which uses a
single pthread_mutex_t to protect all atomic operations. This
implementation is the slow (but safe) fallback implementation
for architectures Qt does not yet support.
EOF
fi
#-------------------------------------------------------------------------------
# check if the user passed the -no-zlib option, which is no longer supported
#-------------------------------------------------------------------------------
if [ -n "$ZLIB_FORCED" ]; then
which_zlib="supplied"
if [ "$CFG_ZLIB" = "system" ]; then
which_zlib="system"
fi
cat <<EOF
NOTICE: The -no-zlib option was supplied but is no longer
supported.
Qt now requires zlib support in all builds, so the -no-zlib
option was ignored. Qt will be built using the $which_zlib
zlib.
EOF
fi
#-------------------------------------------------------------------------------
# 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"
echo "if [ \"\$#\" -gt 0 ]; then" >> "$outpath/config.status"
echo " $CONFIG_STATUS \"\$@\"" >> "$outpath/config.status"
echo "else" >> "$outpath/config.status"
echo " $CONFIG_STATUS" >> "$outpath/config.status"
echo "fi" >> "$outpath/config.status"
chmod +x "$outpath/config.status"
fi
if [ -n "$RPATH_MESSAGE" ]; then
echo
echo "$RPATH_MESSAGE"
fi
MAKE=`basename "$MAKE"`
echo
echo Qt is now configured for building. Just run \'$MAKE\'.
if [ "$relpath" = "$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 To reconfigure, run \'$MAKE confclean\' and \'configure\'.
echo