TDE
/
tqt3
mirror of https://mirror.git.trinitydesktop.org/gitea/TDE/tqt3
0
0
Fork 0
Code Issues Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'ab9c0372a3'
${ noResults }
tqt3/configure

3540 lines
101 KiB
Raw Blame History

#!/bin/sh
#
#
# Configures to build the Qt library
#
# Copyright (C) 1999-2008 Trolltech ASA. All rights reserved.
#
#-------------------------------------------------------------------------------
# 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`
# 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=
SUPPORTED=
#-------------------------------------------------------------------------------
# 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_QNX=no
if [ -f $relpath/src/kernel/qapplication_mac.cpp ] && [ -d /System/Library/Frameworks/Carbon.framework ]; then
# Qt/Mac
# ~ the Carbon SDK exists
# ~ src/kernel/qapplication_mac.cpp is present
# ~ this is the internal edition and Qt/Mac sources exist
PLATFORM_MAC=maybe
elif [ -f $relpath/src/kernel/qapplication_qws.cpp ]; then
# Qt/Embedded
# ~ src/kernel/qapplication_qws.cpp is present
# ~ this is the open source or commercial edition
# ~ this is the internal edition and Qt/Embedded is explicitly enabled
# ~ this is the internal edition and the OS is QNX
if [ "$UNAME_SYSTEM" = "QNX" ]; then
PLATFORM_QNX=maybe
else
PLATFORM_QWS=maybe
fi
fi
#-------------------------------------------------------------------------------
# Free license only: no check for other licenses
#-------------------------------------------------------------------------------
[ "$PLATFORM_MAC" = "maybe" ] && PLATFORM_MAC=yes
[ "$PLATFORM_QWS" = "maybe" ] && PLATFORM_QWS=yes
Edition="free"
Licensee="Free"
Products="qt-free"
# modules depending on free license
MODULES="styles tools kernel widgets dialogs iconview workspace inputmethod \
network canvas table xml opengl sql"
CFG_MODULES_AVAILABLE=$MODULES
QMAKE_VARS="$QMAKE_VARS \"QT_PRODUCT=$Products\""
QMAKE_VARS="$QMAKE_VARS \"styles += windows motif mac platinum sgi cde motifplus\""
QMAKE_VARS="$QMAKE_VARS \"kbd-drivers += tty\" \"mouse-drivers += pc\""
#-------------------------------------------------------------------------------
# initalize variables
#-------------------------------------------------------------------------------
# QTDIR may be set and point to an old or system-wide Qt installation
unset QTDIR
# initalize internal variables
CFG_CONFIGURE_EXIT_ON_ERROR=yes
CFG_PROFILE=no
CFG_EXCEPTION_SUPPORT=unspecified
CFG_INCREMENTAL=auto
CFG_QCONFIG=full
CFG_EMBEDDED=no
CFG_DEBUG=no
CFG_SHARED=yes
CFG_GIF=no
CFG_THREAD=auto
CFG_SM=auto
CFG_XSHAPE=auto
CFG_XINERAMA=auto
CFG_BIG_CODECS=yes
CFG_ZLIB=yes
CFG_PNG=yes
CFG_LIBPNG=system
CFG_JPEG=auto
CFG_LIBJPEG=system
CFG_MNG=auto
CFG_LIBMNG=system
CFG_XCURSOR=auto
CFG_XRANDR=auto
CFG_XRENDER=auto
CFG_FREETYPE=auto
CFG_QWS_FREETYPE=yes
CFG_SQL_AVAILABLE=
CFG_SQL_AUTODETECTED=
CFG_GFX_AVAILABLE=
CFG_STYLE_AVAILABLE=
#Keep this position for CFG_IM* to avoid patch rejection
CFG_IM=yes
CFG_IM_EXT=no
CFG_TABLET=auto
CFG_XKB=auto
CFG_NIS=auto
CFG_CUPS=auto
CFG_LARGEFILE=auto
CFG_NEWABI=no ### need to break ABI for full Large File support...
CFG_STL=auto
CFG_PRECOMPILE=no
CFG_IPV6=auto
CFG_NAS=no
CFG_QWS_DEPTHS=prompted
CFG_USER_BUILD_KEY=
CFG_ACCESSIBILITY=auto
CFG_DLOPEN_OPENGL=no
CFG_ENDIAN=auto
CFG_GLIBMAINLOOP=no
CFG_LIBGLIBMAINLOOP=
D_FLAGS=
I_FLAGS=
L_FLAGS=
R_FLAGS=
l_FLAGS=
QCONFIG_FLAGS=
XPLATFORM=
PLATFORM=$QMAKESPEC
QMAKE_PROJECTS=
QMAKE_IGNORE_PROJECTS=
OPT_CONCURRENT=0
OPT_SHADOW=maybe
OPT_FAST=auto
OPT_VERBOSE=no
OPT_HELP=
# initalize variables used for installation
QT_INSTALL_PREFIX=
QT_INSTALL_DOCS=
QT_INSTALL_HEADERS=
QT_INSTALL_LIBS=
QT_INSTALL_BINS=
QT_INSTALL_PLUGINS=
QT_INSTALL_DATA=
QT_INSTALL_TRANSLATIONS=
QT_INSTALL_SYSCONF=
#-------------------------------------------------------------------------------
# check SQL drivers and styles available in this package
#-------------------------------------------------------------------------------
CFG_SQL_AVAILABLE=`find $relpath/plugins/src/sqldrivers/* -prune -type d -exec basename {} \;`
# normalize whitespace
CFG_SQL_AVAILABLE=`echo $CFG_SQL_AVAILABLE`
CFG_STYLE_AVAILABLE=`find $relpath/plugins/src/styles/* -prune -type d -exec basename {} \;`
# normalize whitespace
CFG_STYLE_AVAILABLE=`echo $CFG_STYLE_AVAILABLE`
#-------------------------------------------------------------------------------
# parse command line arguments
#-------------------------------------------------------------------------------
# parse the arguments, setting things to "yes" or "no"
while [ "$#" -gt 0 ]; do
CURRENT_OPT="$1"
UNKNOWN_ARG=no
case $1 in
#Autoconf style options
--enable-*)
VAR=`echo $1 | sed "s,^--enable-\(.*\),\1,"`
VAL=yes
;;
--disable-*)
VAR=`echo $1 | sed "s,^--disable-\(.*\),\1,"`
VAL=no
;;
--*=*)
VAR=`echo $1 | sed "s,^--\(.*\)=.*,\1,"`
VAL=`echo $1 | sed "s,^--.*=\(.*\),\1,"`
;;
--no-*)
VAR=`echo $1 | sed "s,^--no-\(.*\),\1,"`
VAL=no
;;
--*)
VAR=`echo $1 | sed "s,^--\(.*\),\1,"`
VAL=yes
;;
#Qt plugin options
-no-*-*|-plugin-*-*|-qt-*-*)
VAR=`echo $1 | sed "s,^-[^-]*-\(.*\),\1,"`
VAL=`echo $1 | sed "s,^-\([^-]*\).*,\1,"`
;;
#Qt style no options
-no-*)
VAR=`echo $1 | sed "s,^-no-\(.*\),\1,"`
VAL=no
;;
#Qt style yes options
-incremental|-qvfb|-profile|-shared|-static|-sm|-thread|-xinerama|-xshape|-tablet|-pch|-stl|-ipv6|-freetype|-big-codecs|-xcursor|-xrandr|-xrender|-xft|-xkb|-nis|-cups|-largefile|-h|-help|-v|-verbose|-debug|-release|-fast|-version-script|-dlopen-opengl|-glibmainloop)
VAR=`echo $1 | sed "s,^-\(.*\),\1,"`
VAL=yes
;;
#Qt style options that pass an argument
-qconfig)
if [ "$PLATFORM_QWS" = "yes" ]; then
CFG_QCONFIG="$VAL"
VAR=`echo $1 | sed "s,^-\(.*\),\1,"`
shift
VAL=$1
else
UNKNOWN_ARG=yes
fi
;;
-prefix|-docdir|-headerdir|-plugindir|-datadir|-libdir|-bindir|-translationdir|-sysconfdir|-depths|-make|-nomake|-platform|-xplatform|-buildkey)
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
;;
#Qt style yes options for immodule
#Keep this place to avoid patch rejection
-inputmethod|-inputmethod-ext)
VAR=`echo $1 | sed "s,^-\(.*\),\1,"`
VAL=yes
;;
-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
;;
-*-endian)
VAR=endian
VAL=`echo $1 | sed "s,^-\(.*\)-.*,\1,"`
;;
-j?*)
VAR="concurrent"
VAL="`echo $1 | sed 's,-j,,'`"
;;
-D?*|-D)
VAR="define"
if [ "$1" = "-D" ]; then
shift
VAL="$1"
else
VAL=`echo $1 | sed 's,-D,,'`
fi
;;
-I?*|-I)
VAR="ipath"
if [ "$1" = "-I" ]; then
shift
VAL="$1"
else
VAL=`echo $1 | sed 's,-I,,'`
fi
;;
-L?*|-L)
VAR="lpath"
if [ "$1" = "-L" ]; then
shift
VAL="$1"
else
VAL=`echo $1 | sed 's,-L,,'`
fi
;;
-R?*|-R)
VAR="rpath"
if [ "$1" = "-R" ]; then
shift
VAL="$1"
else
VAL=`echo $1 | sed 's,-R,,'`
fi
;;
-l?*)
VAR="link"
VAL=`echo $1 | sed 's,-l,,'`
;;
*)
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
accessibility)
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
CFG_ACCESSIBILITY="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
prefix)
QT_INSTALL_PREFIX="$VAL"
;;
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"
;;
translationdir)
QT_INSTALL_TRANSLATIONS="$VAL"
;;
sysconfdir)
QT_INSTALL_SYSCONF="$VAL"
;;
qconfig)
CFG_QCONFIG="$VAL"
;;
bindir)
QT_INSTALL_BINS="$VAL"
;;
buildkey)
CFG_USER_BUILD_KEY="$VAL"
;;
embedded)
CFG_EMBEDDED="$VAL"
if [ "$PLATFORM_QNX" != "no" -o "$PLATFORM_QWS" != "no" ]; then
if [ "$PLATFORM_QNX" = "maybe" ]; then
PLATFORM_QNX=yes
elif [ "$PLATFORM_QWS" = "maybe" ]; then
PLATFORM_QWS=yes
fi
else
echo "No license exists to enable Qt/Embedded. Disabling."
CFG_EMBEDDED=no
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
;;
depths)
CFG_QWS_DEPTHS="$VAL"
;;
qvfb) # left for commandline compatibility, not documented
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
[ "$VAL" = "yes" ] && QMAKE_VARS="$QMAKE_VARS \"gfx-drivers += qvfb\""
else
UNKNOWN_OPT=yes
fi
;;
nomake)
QMAKE_IGNORE_PROJECTS="$QMAKE_IGNORE_PROJECTS $VAL"
;;
make)
if [ -f $relpath/$VAL ]; then
QMAKE_PROJECTS="$QMAKE_PROJECTS $relpath/$VAL"
else
if [ -d $relpath/$VAL ]; then
QMAKE_PROJECTS="$QMAKE_PROJECTS `find $relpath/$VAL -name '*.pro' -print`"
else
QMAKE_PROJECTS="$QMAKE_PROJECTS `find $relpath/. -name '*.pro' -print`"
fi
fi
;;
x11)
if [ "$Edition" = "troll" ] && [ "$VAL" = "yes" ]; then
if [ "$PLATFORM_MAC" = "yes" ]; then
PLATFORM_MAC=no
elif [ "$PLATFORM_QWS" = "yes" ]; then
PLATFORM_QWS=no
fi
PLATFORM_X11=yes
else
UNKNOWN_OPT=yes
fi
;;
profile)
if [ "$VAL" = "yes" ]; then
CFG_PROFILE=yes
QMAKE_VARS="$QMAKE_VARS QMAKE_CFLAGS+=-pg QMAKE_CXXFLAGS+=-pg"
QMAKE_VARS="$QMAKE_VARS QMAKE_LFLAGS+=-pg"
else
UNKNOWN_OPT=yes
fi
;;
exceptions|g++-exceptions)
if [ "$VAL" = "no" ]; then
CFG_EXCEPTION_SUPPORT=no
else
UNKNOWN_OPT=yes
fi
;;
version-script)
if [ "$VAL" = "yes" ]; then
QMAKE_CONFIG="$QMAKE_CONFIG version_script"
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-o32)
PLATFORM=irix-cc-o32
;;
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++
;;
esac
;;
xplatform)
XPLATFORM="$VAL"
;;
release)
if [ "$VAL" = "yes" ]; then
CFG_DEBUG=no
elif [ "$VAL" = "no" ]; then
CFG_DEBUG=yes
else
UNKNOWN_OPT=yes
fi
;;
debug)
CFG_DEBUG="$VAL"
;;
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
;;
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
;;
thread)
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
CFG_THREAD="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
xinerama)
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
CFG_XINERAMA="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
xshape)
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
CFG_XSHAPE="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
tablet)
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
CFG_TABLET="$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
;;
ipv6)
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
CFG_IPV6="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
freetype)
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; 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
[ "$VAL" = "no" ] && CFG_LIBPNG=no
;;
libpng)
[ "$VAL" = "yes" ] && VAL=qt
if [ "$VAL" = "no " ]; then
echo "-no-png is left for compatibility, in the future please use -no-imgfmt-png"
CFG_PNG=no
fi
if [ "$VAL" = "qt" ] || [ "$VAL" = "no" ] || [ "$VAL" = "system" ]; then
CFG_LIBPNG="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
libmng)
[ "$VAL" = "yes" ] && VAL=qt
if [ "$VAL" = "no " ]; then
echo "-no-mng is left for compatibility, in the future please use -no-imgfmt-mng"
CFG_MNG=no
fi
if [ "$VAL" = "qt" ] || [ "$VAL" = "no" ] || [ "$VAL" = "system" ]; then
CFG_LIBMNG="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
libjpeg|jpeg)
[ "$VAL" = "yes" ] && VAL=qt
if [ "$VAR" = "jpeg" ]; then
echo "-${VAL}-jpeg is left for compatibility, in the future please use -${VAL}-libjpeg"
fi
if [ "$VAL" = "qt" ] || [ "$VAL" = "no" ] || [ "$VAL" = "system" ]; then
CFG_LIBJPEG="$VAL"
else
UNKNOWN_OPT=yes
fi
if [ "$VAL" = "no " ]; then
echo "-no-jpeg is left for compatibility, in the future please use -no-imgfmt-jpeg"
CFG_JPEG=no
fi
;;
nas-sound)
if [ "$VAL" = "system" ] || [ "$VAL" = "no" ]; then
CFG_NAS="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
big-codecs)
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
CFG_BIG_CODECS="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
xcursor)
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
CFG_XCURSOR="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
xrandr)
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
CFG_XRANDR="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
xrender)
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
CFG_XRENDER="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
xft)
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
CFG_FREETYPE="$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
;;
glibmainloop)
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
CFG_GLIBMAINLOOP="$VAL"
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
;;
newabi)
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
CFG_NEWABI="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
enable) #left for commandline compatibility, not documented
MODULE="$VAL"
if [ -n $MODULE -a -d "$relpath/src/$MODULE" ]; then
if echo "${MODULES}" | grep $MODULE >/dev/null 2>&1; then
MODULES="$MODULES $MODULE"
fi
fi
;;
disable)
MODULE="$VAL"
if [ -d "$relpath/src/$MODULE" ]; then
MODULES=`echo $MODULES | sed -e "s/$MODULE//"`
else
echo "Unknown module disabled: $MODULE"
fi
;;
h|help)
if [ "$VAL" = "yes" ]; then
OPT_HELP="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
imgfmt-*|style-*|sql-*|gfx-*|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,"`
ERROR=no
# now $OPT is "no", "qt", or "plugin"
if [ "$VAR" = "imgfmt" ]; then
[ "$OPT" = "qt" ] && OPT=yes
# now $OPT is "no", "yes", or "plugin"
case "$VAL" in
jpeg) CFG_JPEG=$OPT ;;
mng) CFG_MNG=$OPT ;;
png) CFG_PNG=$OPT ;;
*) ERROR=yes ;;
esac
else
if [ "$VAR" = "style" ]; then
ERROR=yes
for d in $CFG_STYLE_AVAILABLE; do
if [ "$VAL" = "$d" ]; then
ERROR=no
break
fi
done
elif [ "$VAR" = "sql" ]; then
ERROR=yes
for d in $CFG_SQL_AVAILABLE; do
if [ "$VAL" = "$d" ]; then
ERROR=no
break
fi
done
fi
if [ "$OPT" = "plugin" ] || [ "$OPT" = "qt" ]; then
if [ "$OPT" = "plugin" ]; then
[ "$VAR" = "style" ] && QMAKE_VARS="$QMAKE_VARS \"${VAR}s -= $VAL\""
VAR="${VAR}-${OPT}"
else
if [ "$VAR" = "sql" ] || [ "$VAR" = "gfx" ] || [ "$VAR" = "kbd" ] || [ "$VAR" = "mouse" ]; then
VAR="${VAR}-driver"
fi
fi
QMAKE_VARS="$QMAKE_VARS \"${VAR}s += $VAL\""
elif [ "$OPT" = "no" ]; then
PLUG_VAR="${VAR}-plugin"
if [ "$VAR" = "sql" ] || [ "$VAR" = "gfx" ] || [ "$VAR" = "kbd" ] || [ "$VAR" = "mouse" ]; then
IN_VAR="${VAR}-driver"
else
IN_VAR="${VAR}"
fi
QMAKE_VARS="$QMAKE_VARS \"${IN_VAR}s -= $VAL\" \"${PLUG_VAR}s -= $VAL\""
fi
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
;;
concurrent)
OPT_CONCURRENT="$VAL"
;;
define)
D_FLAGS="$D_FLAGS $VAL"
;;
ipath)
I_FLAGS="$I_FLAGS -I${VAL}"
;;
lpath)
L_FLAGS="$L_FLAGS -L${VAL}"
;;
rpath)
R_FLAGS="$R_FLAGS \$\${QMAKE_RPATH}${VAL}"
;;
link)
l_FLAGS="$l_FLAGS -l${VAL}"
;;
dlopen-opengl)
CFG_DLOPEN_OPENGL="$VAL"
;;
inputmethod)
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
CFG_IM="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
inputmethod-ext)
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
CFG_IM_EXT="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
*)
UNKNOWN_OPT=yes
;;
esac
if [ "$UNKNOWN_OPT" = "yes" ]; then
echo "${CURRENT_OPT}: invalid command-line switch"
OPT_HELP=yes
ERROR=yes
fi
done
#-------------------------------------------------------------------------------
# post initialize QT_INSTALL_* variables, and generate qconfig.cpp
#-------------------------------------------------------------------------------
# default $outpath
[ -z "$QT_INSTALL_PREFIX" ] && QT_INSTALL_PREFIX=$outpath
# default PREFIX/doc
[ -z "$QT_INSTALL_DOCS" ] && QT_INSTALL_DOCS=$QT_INSTALL_PREFIX/doc
# default PREFIX/include
[ -z "$QT_INSTALL_HEADERS" ] && QT_INSTALL_HEADERS=$QT_INSTALL_PREFIX/include
# default PREFIX/lib
[ -z "$QT_INSTALL_LIBS" ] && QT_INSTALL_LIBS=$QT_INSTALL_PREFIX/lib
# default PREFIX/bin
[ -z "$QT_INSTALL_BINS" ] && QT_INSTALL_BINS=$QT_INSTALL_PREFIX/bin
# default PREFIX/plugins
[ -z "$QT_INSTALL_PLUGINS" ] && QT_INSTALL_PLUGINS=$QT_INSTALL_PREFIX/plugins
# default PREFIX
[ -z "$QT_INSTALL_DATA" ] && QT_INSTALL_DATA=$QT_INSTALL_PREFIX
# default PREFIX/translations
[ -z "$QT_INSTALL_TRANSLATIONS" ] && QT_INSTALL_TRANSLATIONS=$QT_INSTALL_PREFIX/translations
# default PREFIX/etc/settings
[ -z "$QT_INSTALL_SYSCONF" ] && QT_INSTALL_SYSCONF=$QT_INSTALL_PREFIX/etc/settings
# generate qconfig.cpp
[ -d $outpath/src/tools ] || mkdir -p $outpath/src/tools
cat > $outpath/src/tools/qconfig.cpp.new <<EOF
/* Install paths from configure */
#include "ntqglobal.h"
static const char QT_INSTALL_PREFIX [267] = "qt_nstpath=$QT_INSTALL_PREFIX";
static const char QT_INSTALL_BINS [267] = "qt_binpath=$QT_INSTALL_BINS";
static const char QT_INSTALL_DOCS [267] = "qt_docpath=$QT_INSTALL_DOCS";
static const char QT_INSTALL_HEADERS [267] = "qt_hdrpath=$QT_INSTALL_HEADERS";
static const char QT_INSTALL_LIBS [267] = "qt_libpath=$QT_INSTALL_LIBS";
static const char QT_INSTALL_PLUGINS [267] = "qt_plgpath=$QT_INSTALL_PLUGINS";
static const char QT_INSTALL_DATA [267] = "qt_datpath=$QT_INSTALL_DATA";
static const char QT_INSTALL_TRANSLATIONS[267] = "qt_trnpath=$QT_INSTALL_TRANSLATIONS";
static const char QT_INSTALL_SYSCONF [267] = "qt_cnfpath=$QT_INSTALL_SYSCONF";
/* strlen( "qt_xxxpath=" ) == 11 */
const char *tqInstallPath() { return QT_INSTALL_PREFIX + 11; }
const char *tqInstallPathDocs() { return QT_INSTALL_DOCS + 11; }
const char *tqInstallPathHeaders() { return QT_INSTALL_HEADERS + 11; }
const char *tqInstallPathLibs() { return QT_INSTALL_LIBS + 11; }
const char *tqInstallPathBins() { return QT_INSTALL_BINS + 11; }
const char *tqInstallPathPlugins() { return QT_INSTALL_PLUGINS + 11; }
const char *tqInstallPathData() { return QT_INSTALL_DATA + 11; }
const char *tqInstallPathTranslations() { return QT_INSTALL_TRANSLATIONS + 11; }
const char *tqInstallPathSysconf() { return QT_INSTALL_SYSCONF + 11; }
EOF
# avoid unecessary rebuilds by copying only if qconfig.cpp has changed
if cmp -s $outpath/src/tools/qconfig.cpp $outpath/src/tools/qconfig.cpp.new; then
rm -f $outpath/src/tools/qconfig.cpp.new
else
[ -f $outpath/src/tools/qconfig.cpp ] && chmod +w $outpath/src/tools/qconfig.cpp
mv $outpath/src/tools/qconfig.cpp.new $outpath/src/tools/qconfig.cpp
chmod -w $outpath/src/tools/qconfig.cpp
fi
#-------------------------------------------------------------------------------
# build tree initialization
#-------------------------------------------------------------------------------
#where to find which..
unixtests=$relpath/config.tests/unix
WHICH=$unixtests/which.test
### skip this if the user just needs help...
if [ "$OPT_HELP" != "yes" ]; then
# create the include and include/qmake directory (for ntqconfig.h and ntqmodules.h)
[ -d $outpath/include/qmake ] || mkdir -p $outpath/include/qmake
# create temporary ntqconfig.h for compiling qmake
# when building qmake, we use #defines for the install paths,
# however they are real functions in the library
cat >>$outpath/include/qmake/ntqconfig.h <<EOF
/* All features enabled while building qmake */
EOF
# create temporary ntqmodules.h for compiling qmake
cat >>$outpath/include/qmake/ntqmodules.h <<EOF
/* All modules enabled while building qmake */
EOF
# 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_VERBOSE" = "yes" -a "$OPT_SHADOW" = "yes" ]; then
echo "Performing shadow build..."
fi
#detect how mng should be built
if [ "$CFG_MNG" = "auto" ]; then
if [ "$CFG_EMBEDDED" = "yes" ]; then
CFG_MNG=no
elif [ "$CFG_SHARED" = "yes" ]; then
CFG_MNG=plugin
else
CFG_MNG=yes
fi
fi
#detect how jpeg should be built
if [ "$CFG_JPEG" = "auto" ]; then
if [ "$CFG_EMBEDDED" = "yes" ]; then
CFG_JPEG=no
elif [ "$CFG_MNG" = "yes" ]; then
CFG_JPEG=yes
elif [ "$CFG_SHARED" = "yes" ]; then
CFG_JPEG=plugin
else
CFG_JPEG=yes
fi
fi
#detect accessibility
if [ "$CFG_ACCESSIBILITY" = "auto" ]; then
if [ "$PLATFORM_MAC" = "yes" ]; then
CFG_ACCESSIBILITY=yes
else
CFG_ACCESSIBILITY=no
fi
fi
# if the source tree is different from the build tree,
# symlink or copy part of the sources
if [ "$OPT_SHADOW" = "yes" ]; then
echo "Preparing build tree..."
[ -d $outpath/bin ] || mkdir -p $outpath/bin
# need a top level makefile, prefer gnu internally
if [ -f $relpath/GNUmakefile ]; then
rm -f $outpath/Makefile
ln -s $relpath/GNUmakefile $outpath/Makefile
elif [ -f $relpath/Makefile ]; then
rm -f $outpath/Makefile
ln -s $relpath/Makefile $outpath/Makefile
else
echo "No top level Makefile." >&2
exit 1
fi
# symlink the qmake directory
for a in `find $relpath/qmake`; 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
# 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 linguist/doc directory (to make the assistant happy)
mkdir -p $outpath/tools/linguist
rm -f $outpath/tools/linguist/doc
ln -s $relpath/tools/linguist/doc $outpath/tools/linguist/doc
# symlink the designer/templates directory (to make the designer find
# the templates)
mkdir -p $outpath/tools/designer
rm -f $outpath/tools/designer/templates
ln -s $relpath/tools/designer/templates $outpath/tools/designer/templates
# symlink the designer/interfaces directory (for the validator)
rm -f $outpath/tools/designer/interfaces
ln -s $relpath/tools/designer/interfaces $outpath/tools/designer/interfaces
# symlink designer/editor/editor.h, dlldefs.h, viewmanager.h (for the validator)
mkdir -p $outpath/tools/designer/editor
rm -f $outpath/tools/designer/editor/editor.h
ln -s $relpath/tools/designer/editor/editor.h $outpath/tools/designer/editor/editor.h
rm -f $outpath/tools/designer/editor/dlldefs.h
ln -s $relpath/tools/designer/editor/dlldefs.h $outpath/tools/designer/editor/dlldefs.h
rm -f $outpath/tools/designer/editor/viewmanager.h
ln -s $relpath/tools/designer/editor/viewmanager.h $outpath/tools/designer/editor/viewmanager.h
# symlink the doc directory
rm -f $outpath/doc
ln -s $relpath/doc $outpath/doc
else
# override the Windows Makefile
if [ -f "$relpath/GNUmakefile" ]; then
[ "$Edition" = "troll" ] && $WHICH chflags >/dev/null 2>&1 && chflags nouchg $outpath/Makefile
rm -f $outpath/Makefile
cp $relpath/GNUmakefile $outpath/Makefile
chmod +w $outpath/Makefile
fi
fi
# binaries from qt
QMAKE_VARS="$QMAKE_VARS \"QMAKE_MOC=$outpath/bin/tqmoc\""
QMAKE_VARS="$QMAKE_VARS \"QMAKE_UIC=$outpath/bin/tquic -L \$\$QT_BUILD_TREE/plugins\""
QMAKE_VARS="$QMAKE_VARS \"QMAKE_QMAKE=$outpath/bin/tqmake\""
# hacky src line
QMAKE_VARS="$QMAKE_VARS \"QMAKE_MOC_SRC=$outpath/src/moc\""
# 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
if [ "$OPT_FAST" = "auto" ]; then
if [ ! -z "$AWK" ] && [ "$Edition" = "troll" ]; then
OPT_FAST=yes
else
OPT_FAST=no
fi
fi
# find a make command
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 "You don't seem to have 'make' or 'gmake' in your PATH."
echo "Cannot proceed."
exit 1
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
QNX:*)
[ -z "$PLATFORM" ] && PLATFORM=qws/qnx-rtp-g++
# [ "$CFG_EMBEDDED" = "qnx4" ] && PLATFORM_QNX=qws/qnx4-cc
if [ -z "$XPLATFORM" ]; then
[ "$CFG_EMBEDDED" = "auto" ] && CFG_EMBEDDED=generic
XPLATFORM="$PLATFORM"
fi
CFG_STL=no
CFG_QWS_QVFB=no
;;
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:*|GNU:*|GNU/*:*)
if [ -z "$PLATFORM" ]; then
case "$UNAME_MACHINE" in
*86)
PLATFORM=qws/linux-x86-g++
;;
*)
PLATFORM=qws/linux-generic-g++
;;
esac
fi
if [ -z "$XPLATFORM" ]; then
if [ "$CFG_EMBEDDED" = "auto" ]; then
case "$UNAME_MACHINE" in
*86)
CFG_EMBEDDED=x86
;;
*)
CFG_EMBEDDED=generic
;;
esac
fi
XPLATFORM="qws/linux-$CFG_EMBEDDED-g++"
fi
;;
*)
echo "Qt/Embedded is not supported on this platform. Disabling."
CFG_EMBEDDED=no
PLATFORM_QWS=no
PLATFORM_QNX=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-pbuilder
else
PLATFORM=darwin-g++
fi
;;
AIX:*)
#PLATFORM=aix-g++
PLATFORM=aix-xlc
#PLATFORM=aix-xlc-64
PLATFORM_NOTES="
- Also available for AIX: aix-g++ aix-xlc-64
"
;;
QNX:*)
PLATFORM=qnx-g++
;;
dgux:*)
PLATFORM=dgux-g++
;;
# DYNIX/ptx:4*)
# PLATFORM=dynix-g++
# ;;
ULTRIX:*)
PLATFORM=ultrix-g++
;;
FreeBSD:*)
PLATFORM=freebsd-g++
;;
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:*)
#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
"
;;
OSF1:*)
#PLATFORM=tru64-g++
PLATFORM=tru64-cxx
PLATFORM_NOTES="
- Also available for Tru64: tru64-g++
"
;;
Linux:*|GNU:*|GNU/*:*)
PLATFORM=linux-g++
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++
;;
*)
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" -o "$PLATFORM_QNX" = "yes" ]; then
CFG_SM=no
MODULES=`echo $MODULES | sed -e 's/opengl//'`
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
##if [ "$OPT_CONCURRENT" = "0" ] && echo $MAKEFLAGS | grep '.* *-j[0-9]* *.*' >/dev/null 2>&1; then
# OPT_CONCURRENT=`echo $MAKEFLAGS | sed "s,.* *-j\([0-9]*\) *.*,\1,"`
#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 [ "$QMAKESPEC" = "$XQMAKESPEC" ]; then
QMAKE_CONFIG="$QMAKE_CONFIG nocrosscompiler"
fi
if [ "$PLATFORM_MAC" = "yes" ]; then
if [ `basename $QMAKESPEC` = "macx-pbuilder" ] || [ `basename $XQMAKESPEC` = "macx-pbuilder" ]; then
echo >&2
echo " Platform 'macx-pbuilder' 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-pbuilder 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 PLATFORMS 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 PLATFORMS 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
[ '!' -z "`grep QMAKE_LIBS_X11 $XQMAKESPEC/qmake.conf | awk '{print $3;}'`" ] && PLATFORM_X11=yes
### echo "$XQMAKESPEC" | grep mkspecs/qws >/dev/null 2>&1 && PLATFORM_QWS=yes
# find default thread option for target
if grep >/dev/null '^QMAKE_LIBS_THREAD' $XQMAKESPEC/qmake.conf; then
AUTOTHREAD=yes
AUTOTHREAD=no ### leave off for now
else
AUTOTHREAD=never
fi
# common qmake.conf file but dependency on OS version
if [ "$UNAME_SYSTEM" = "HP-UX" ]; then
if echo $UNAME_RELEASE | grep -E "^B\.(09|10)" >/dev/null 2>&1; then
AUTOTHREAD=never
fi
fi
if [ "$UNAME_SYSTEM" = "SunOS" ]; then
# Solaris 2.5 and 2.6 have libposix4, which was renamed to librt for Solaris >=7
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
if [ $AUTOTHREAD = never ]; then
if [ "$CFG_THREAD" = "yes" ]; then
echo
echo "ERROR: Qt is not configured to support threading on this platform"
echo " See the THREAD settings in $XQMAKESPEC/qmake.conf"
echo
exit 2
fi
AUTOTHREAD=no
fi
[ "$CFG_THREAD" = "auto" ] && CFG_THREAD=$AUTOTHREAD
#-------------------------------------------------------------------------------
# tests that don't need qmake (must be run before displaying help)
#-------------------------------------------------------------------------------
# auto-detect precompiled header support
if [ "$CFG_PRECOMPILE" = "auto" ]; then
if $unixtests/precomp.test $XQMAKESPEC $OPT_VERBOSE; then
CFG_PRECOMPILE=no
else
CFG_PRECOMPILE=yes
fi
fi
# auto-detect SQL-modules support
if echo $MODULES | grep sql >/dev/null; then
MYSQL_REQ="-lmysqlclient mysql.h"
OCI_REQ="-lclntsh -lwtc8 oci.h"
PSQL_REQ="-lpq postgres.h libpq/libpq-fs.h catalog/pg_type.h libpq-fe.h"
ODBC_REQ="-lodbc sql.h sqlext.h"
TDS_REQ="-lsybdb sybfront.h sybdb.h"
DB2_REQ="-ldb2 sqlcli.h sqlcli1.h"
IBASE_REQ="-lfbclient ibase.h"
for _SQLDR in $CFG_SQL_AVAILABLE; do
case $_SQLDR in
mysql)
$unixtests/checkavail "MySQL" $OPT_VERBOSE $MYSQL_REQ $L_FLAGS $I_FLAGS && CFG_SQL_AUTODETECTED="$CFG_SQL_AUTODETECTED mysql"
;;
psql)
$unixtests/checkavail "PostgreSQL" $OPT_VERBOSE $PSQL_REQ $L_FLAGS $I_FLAGS && CFG_SQL_AUTODETECTED="$CFG_SQL_AUTODETECTED psql"
;;
odbc)
$unixtests/checkavail "ODBC" $OPT_VERBOSE $ODBC_REQ $L_FLAGS $I_FLAGS && CFG_SQL_AUTODETECTED="$CFG_SQL_AUTODETECTED odbc"
;;
oci)
$unixtests/checkavail "OCI" $OPT_VERBOSE $OCI_REQ $L_FLAGS $I_FLAGS && CFG_SQL_AUTODETECTED="$CFG_SQL_AUTODETECTED oci"
;;
tds)
$unixtests/checkavail "TDS" $OPT_VERBOSE $TDS_REQ $L_FLAGS $I_FLAGS && CFG_SQL_AUTODETECTED="$CFG_SQL_AUTODETECTED tds"
;;
db2)
$unixtests/checkavail "DB2" $OPT_VERBOSE $DB2_REQ $L_FLAGS $I_FLAGS && CFG_SQL_AUTODETECTED="$CFG_SQL_AUTODETECTED db2"
;;
ibase)
$unixtests/checkavail "IBASE" $OPT_VERBOSE $IBASE_REQ $L_FLAGS $I_FLAGS && CFG_SQL_AUTODETECTED="$CFG_SQL_AUTODETECTED ibase"
;;
sqlite)
if [ -f $relpath/src/3rdparty/sqlite/sqlite.h ]; then
CFG_SQL_AUTODETECTED="$CFG_SQL_AUTODETECTED sqlite"
fi
;;
*)
if [ "$OPT_VERBOSE" = "yes" ]; then
echo "unknown SQL driver: $_SQLDR"
fi
;;
esac
done
fi
# auto-detect NIS support
if [ "$CFG_NIS" != "no" ]; then
if $unixtests/nis.test $XQMAKESPEC $OPT_VERBOSE $L_FLAGS $I_FLAGS; then
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
else
CFG_NIS=yes
fi
fi
# auto-detect CUPS support
if [ "$CFG_CUPS" != "no" ]; then
if $unixtests/cups.test $XQMAKESPEC $OPT_VERBOSE $L_FLAGS $I_FLAGS; then
if [ "$CFG_CUPS" = "yes" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
echo "Cups support cannot be enabled due to functionality tests!"
echo " Turn on verbose messaging (-v) to $0 to see the final report."
echo " If you believe this message is in error you may use the continue"
echo " switch (-continue) to $0 to continue."
exit 101
else
CFG_CUPS=no
fi
else
CFG_CUPS=yes
fi
fi
#mac
QT_MAC_VERSION=
if [ "$PLATFORM_MAC" = "yes" ]; then
mactests=$relpath/config.tests/mac
QT_MAC_VERSION=`$mactests/mac_version.test "$OPT_VERBOSE" "$relpath" "$outpath"`
if [ "$CFG_TABLET" = "auto" ]; then
CFG_TABLET=yes
fi
fi
# x11
if [ "$PLATFORM_X11" = "yes" ]; then
x11tests=$relpath/config.tests/x11
# auto-detect OpenGL support
if echo $MODULES | grep opengl >/dev/null; then
if $x11tests/opengl.test $XQMAKESPEC $CFG_THREAD $OPT_VERBOSE $L_FLAGS $I_FLAGS; then
MODULES=`echo $MODULES | sed -e 's/opengl//'`
else
if [ "$CFG_DLOPEN_OPENGL" = "yes" ]; then
QMAKE_CONFIG="$QMAKE_CONFIG dlopen_opengl"
fi
fi
fi
# auto-detect Xcursor support
if [ "$CFG_XCURSOR" != "no" ]; then
if $x11tests/xcursor.test $XQMAKESPEC $OPT_VERBOSE $L_FLAGS $I_FLAGS; then
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
else
CFG_XCURSOR=yes
fi
fi
# auto-detect XRandR support (resize and rotate extension)
if [ "$CFG_XRANDR" != "no" ]; then
if $x11tests/xrandr.test $XQMAKESPEC $OPT_VERBOSE $L_FLAGS $I_FLAGS; then
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
else
CFG_XRANDR=yes
fi
fi
# auto-detect XRender support
if [ "$CFG_XRENDER" != "no" ]; then
if $x11tests/xrender.test $XQMAKESPEC $OPT_VERBOSE $L_FLAGS $I_FLAGS; then
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
CFG_FREETYPE=no
fi
else
CFG_XRENDER=yes
fi
else
CFG_FREETYPE=no
fi
# auto-detect Xft support
if [ "$CFG_XRENDER" = "yes" ] && [ "$CFG_FREETYPE" != "no" ]; then
mkdir -p $outpath/config.tests/x11
if $x11tests/xfreetype.test $XQMAKESPEC $OPT_VERBOSE $relpath $outpath $L_FLAGS $I_FLAGS; then
if [ "$CFG_FREETYPE" = "yes" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
echo "Xft 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_FREETYPE=no
fi
else
CFG_FREETYPE=yes
fi
fi
# add freetype2 include path
if [ "$CFG_FREETYPE" = "yes" ] && [ -f $outpath/config.tests/x11/xft.inc ];then
QMAKE_VARS="$QMAKE_VARS \"INCLUDEPATH+=`cat $outpath/config.tests/x11/xft.inc`\""
fi
rm -f $outpath/config.tests/x11/xft.inc
# add Xft specific libraries
if [ "$CFG_FREETYPE" = "yes" ] && [ -f $outpath/config.tests/x11/xft.lib ]; then
QMAKE_VARS="$QMAKE_VARS \"QMAKE_LIBS_X11=`cat $outpath/config.tests/x11/xft.lib` \$\$QMAKE_LIBS_X11\""
fi
rm -f $outpath/config.tests/x11/xft.lib
# add Xft specific config options
if [ "$CFG_FREETYPE" = "yes" ] && [ -f $outpath/config.tests/x11/xft.cfg ]; then
QMAKE_CONFIG="$QMAKE_CONFIG `cat $outpath/config.tests/x11/xft.cfg`"
fi
rm -f $outpath/config.tests/x11/xft.cfg
# auto-detect Session Management support
if [ "$CFG_SM" = "auto" ]; then
if $x11tests/sm.test $XQMAKESPEC $OPT_VERBOSE $L_FLAGS $I_FLAGS; then
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
else
CFG_SM=yes
fi
fi
# auto-detect SHAPE support
if [ "$CFG_XSHAPE" != "no" ]; then
if $x11tests/xshape.test $XQMAKESPEC $OPT_VERBOSE $L_FLAGS $I_FLAGS; then
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
else
CFG_XSHAPE=yes
fi
fi
# auto-detect Xinerama support
if [ "$CFG_XINERAMA" != "no" ]; then
if $x11tests/xinerama.test $XQMAKESPEC $OPT_VERBOSE $L_FLAGS $I_FLAGS; then
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
else
CFG_XINERAMA=yes
fi
fi
# auto-detect tablet support (currenlty only in IRIX)
if [ "$CFG_TABLET" = "auto" ]; then
case $PLATFORM in
irix-*)
if $x11tests/xinput.test $XQMAKESPEC $OPT_VERBOSE $L_FLAGS $I_FLAGS; then
if [ "$CFG_TABLET" = "yes" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
echo "Tablet 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_TABLET=no
fi
else
CFG_TABLET=yes
fi
;;
*)
CFG_TABLET=no
### add error message for the "yes" case on non-IRIX systems
;;
esac
fi
# auto-detect XKB support
if [ "$CFG_XKB" != "no" ]; then
if $x11tests/xkb.test $XQMAKESPEC $OPT_VERBOSE $L_FLAGS $I_FLAGS; then
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
else
CFG_XKB=yes
fi
fi
fi
# embedded graphics
if [ "$PLATFORM_QWS" = "yes" ]; then
CFG_GFX_AVAILABLE=`find $relpath/plugins/src/gfxdrivers/* -prune -type d -print | awk -F/ '{print $NF}'`
CFG_GFX_AVAILABLE=`echo $CFG_GFX_AVAILABLE`
fi
# immodule extensions
if [ "$CFG_IM" = "no" ]; then
CFG_IM_EXT=no
fi
if [ "$CFG_IM_EXT" = "yes" ]; then
CFG_IM=yes
fi
#-------------------------------------------------------------------------------
# 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_THREAD" = "yes" ]; then
THY="*"
THN=" "
else
THY=" "
THN="*"
fi
if [ "$CFG_NIS" = "no" ]; then
NSY=" "
NSN="*"
else
NSY="*"
NSN=" "
fi
if [ "$CFG_CUPS" = "no" ]; then
CUY=" "
CUN="*"
else
CUY="*"
CUN=" "
fi
if [ "$CFG_LARGEFILE" = "no" ]; then
LFSY=" "
LFSN="*"
else
LFSY="*"
LFSN=" "
fi
if [ "$CFG_STL" = "auto" ]; then
SHY="*"
SHN=" "
else
SHY=" "
SHN="*"
fi
if [ "$CFG_PRECOMPILE" = "auto" ]; then
PHY="*"
PHN=" "
else
PHY=" "
PHN="*"
fi
if [ "$CFG_IPV6" = "auto" ]; then
I6Y="*"
I6N=" "
else
I6Y=" "
I6N="*"
fi
cat <<EOF
Usage: $relconf [-prefix dir] [-buildkey key] [-docdir dir] [-headerdir dir]
[-libdir dir] [-bindir dir] [-plugindir dir ] [-datadir dir]
[-translationdir dir] [-sysconfdir dir] [-debug] [-release]
[-no-gif] [-qt-gif] [-no-sm] [-sm] [-qt-zlib] [-system-zlib]
[-qt-libpng] [-system-libpng]
[-qt-libmng] [-system-libmng] [-no-thread] [-thread] [-no-nis] [-nis]
[-no-cups] [-cups] [-no-largefile] [-largefile] [-version-script]
[-no-stl] [-stl] [-no-ipv6 ] [-ipv6] [-Istring] [-lstring]
[-Lstring] [-Rstring] [-disable-<module>] [-with-<module setting>]
[-without-<module setting>] [-fast] [-no-fast]
Installation options:
These are optional, but you may specify install directories.
-prefix dir ........ This will install everything relative dir
(default $QT_INSTALL_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)
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. If marked with a plus (+) a test
for that feature has not been done yet, but will be evaluated later, the
plus simply denotes the default value. 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.
* -shared ............ Create and use a shared Qt library (libqt.so).
-static ............ Create and use a static Qt library (libqt.a).
* -no-gif ............ Do not compile in GIF reading support.
-qt-gif ............ Compile in GIF reading support.
See src/kernel/ntqgif.h
* -qt-zlib ........... Use the zlib bundled with Qt.
-system-zlib ....... Use zlib from the operating system.
See http://www.gzip.org/zlib
-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-fast ........... Configure Qt normally by generating Makefiles for all
project files.
-no-exceptions ..... Disable exceptions on platforms that support it.
-version-script .... Use a version script when linking the Qt library.
Internal symbols will be marked as local. Requires
a recent GNU binutils package.
WARNING: Experimental, may be removed in future
versions.
-platform target ... The operating system and compiler you are building
on ($PLATFORM).
-xplatform target .. The target platform when cross-compiling.
See the PLATFORMS file for a list of supported
operating systems and compilers.
-Dstring ........... Add an explicit define to the preprocessor.
-Istring ........... Add an explicit include path.
-Lstring ........... Add an explicit library path.
-Rstring ........... Add an explicit dynamic library runtime search path.
-lstring ........... Add an explicit library.
-disable-<module> ..... Disable <module> where module is one of:
[ $CFG_MODULES_AVAILABLE ]
-qt-sql-<driver> ...... Enable a SQL <driver> in the Qt Library, by default
none are turned on.
-plugin-sql-<driver> .. Enable SQL <driver> as a plugin to be linked to
at run time.
-no-sql-<driver> ...... Disable SQL <driver> entirely.
Possible values for <driver>:
[ $CFG_SQL_AVAILABLE ]
Auto-Detected on this system:
[$CFG_SQL_AUTODETECTED ]
By default none of the SQL drivers are built,
even if they are auto-detected.
-qt-style-<style> ..... Enable a GUI <style> in the Qt Library, by default
all available styles are on.
-plugin-style-<style> . Enable GUI <style> as a plugin to be linked to
at run time.
-no-style-<style> ..... Disable GUI <style> entirely.
Possible values for <style>:
[ $CFG_STYLE_AVAILABLE ]
$THN -no-thread ............ Do not compile threading support.
$THY -thread ............... Compile threading support.
$NSN -no-nis ............... Do not compile NIS support.
$NSY -nis .................. Compile NIS support.
$PHN -no-pch ............... Do not use precompiled header support.
$PHY -pch .................. Use precompiled header support.
$CUN -no-cups............... Do not compile CUPS support.
$CUY -cups ................. Compile CUPS support.
$SHN -no-stl ............... Do not compile STL support.
$SHY -stl .................. Compile STL support.
$I6N -no-ipv6 .............. Do not compile IPv6 support.
$I6Y -ipv6 ................. Compile IPv6 support.
-verbose .............. Print verbose information about each step of the
-v .................... configure process.
-continue.............. Continue as far as possible if an error occurs.
-help ................. Print help and usage information.
-h .................... Print help and usage information.
Image Formats:
-plugin-imgfmt-<format> Enable <format> to be linked to at runtime.
Uses specified lib<format>.
-qt-imgfmt-<format> ... Enable <format> to be linked into Qt.
Uses specified lib<format>.
-no-imgfmt-<format> ... Fully disable <format> from Qt.
Possible values for <format>:
[ png jpeg mng ]
Third Party Image Loading Libraries:
-qt-libpng ......... Use the libpng bundled with Qt.
* -system-libpng ..... Use libpng from the operating system.
See http://www.libpng.org/pub/png
-qt-libmng ......... Use the libmng bundled with Qt.
* -system-libmng ..... Use libmng from the operating system.
See http://www.libmng.com
EOF
if [ "$PLATFORM_MAC" = "yes" ]; then
cat << EOF
Qt/Mac only:
-no-tablet ......... Do not compile Tablet support.
* -tablet ............ Compile Tablet support.
-no-accessibility .. Do not compile Accessibility support.
* -accessibility ..... Compile Accessibility support.
EOF
fi
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
XRY=" "
XRN="*"
else
XRY="*"
XRN=" "
fi
if [ "$CFG_FREETYPE" = "no" ]; then
XFTY=" "
XFTN="*"
else
XFTY="*"
XFTN=" "
fi
if [ "$CFG_XCURSOR" = "no" ]; then
XCY=" "
XCN="*"
else
XCY="*"
XCN=" "
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_TABLET" = "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
if [ "$CFG_IM_EXT" = "no" ]; then
IXY=" "
IXN="*"
else
IXY="*"
IXN=" "
fi
cat << EOF
Qt/X11 only:
* -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
$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.
$XRN -no-xinerama ....... Do not compile Xinerama (multihead) support.
$XRY -xinerama .......... Compile Xinerama support.
Requires X11/extensions/Xinerama.h and libXinerama.
$XCN -no-xcursor ........ Do not compile Xcursor support.
$XCY -xcursor ........... Compile Xcursor support.
Requires X11/Xcursor/Xcursor.h and libXcursor.
$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 Xft support (see -xft below),
X11/extensions/Xrender.h and libXrender
$XFTN -no-xft ............ Do not compile Xft (anti-aliased font) support.
$XFTY -xft ............... Compile Xft support.
Requires X11/Xft/Xft.h and libXft.
$XIN -no-tablet ......... Do not compile Tablet support.
$XIY -tablet ............ Compile Tablet support.
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.
* -no-dlopen-opengl .. Qt links against OpenGL libraries directly.
-dlopen-opengl ..... Qt uses dlopen(3) to resolve OpenGL functions
(instead of linking with OpenGL libraries directly).
$IMN -no-inputmethod .... Do not compile immodule (extensible input method)
support.
$IMY -inputmethod ....... Compile immodule support.
$IXN -no-inputmethod-ext Do not compile more immodule extensions support.
$IXY -inputmethod-ext ... Compile more immodule extensions support.
(breaks ABI with standard TQt3).
EOF
fi
if [ "$PLATFORM_QWS" = "yes" -o "$PLATFORM_QNX" = "yes" ]; then
cat << EOF
Qt/Embedded only:
-embedded arch...... This will enable the embedded build, you must have a
proper license for this switch to work.
-little-endian ..... Target platform is little endian (LSB first).
-big-endian ........ Target 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 ....... Qt/Embedded only: do not compile in FreeType2 support.
* -freetype .......... Qt/Embedded only: add FreeType2 font support.
-no-zlib ........... No compression library -- implies -no-libpng
-qconfig local ..... Use src/tools/qconfig-local.h rather than the
default ($CFG_QCONFIG).
-depths list ....... Comma-separated list of supported bit-per-pixel
depths, from: 4, 8, 16, 24, and 32.
(8bpp is required by the VGA16 driver)
-qt-gfx-<driver> ... Enable a graphics <driver> in the Qt Library.
-plugin-gfx-<driver> Enable graphics <driver> as a plugin to be
linked to at run time.
-no-gfx-<driver> ... Disable graphics <driver> entirely.
Possible values for <driver>: [ $CFG_GFX_AVAILABLE ]
-qt-kbd-<driver> ... Enable a keyboard <driver> in the Qt Library.
-no-kbd-<driver> ... Disable keyboard <driver> entirely.
Possible values for <driver>: [ sl5000 tty usb yopy vr41xx ]
-qt-mouse-<driver> . Enable a mouse <driver> in the Qt Library.
-no-mouse-<driver> . Disable mouse <driver> entirely.
Possible values for <driver>: [ pc bus linuxtp yopy vr41xx ]
EOF
fi
[ "x$ERROR" = "xyes" ] && exit 1
exit 0
fi
# -----------------------------------------------------------------------------
# LICENSING
# -----------------------------------------------------------------------------
echo
if [ "$PLATFORM_QWS" = "yes" ]; then
echo "This is the Qt/Embedded Open Source Edition."
elif [ "$PLATFORM_MAC" = "yes" ]; then
echo "This is the Qt/Mac Open Source Edition."
elif [ "$PLATFORM_X11" = "yes" ]; then
echo "This is the Qt/X11 Open Source Edition."
else
echo "Internal error: unknown platform."
echo
exit 2
fi
echo
echo "You are licensed to use this software under the terms of"
echo "the GNU General Public License (GPL) versions 2 or 3."
echo
# work around for broken system header files in IRIX 6.5.18 - 6.5.22
case "$PLATFORM" in
irix-cc*)
IRIX_VERSION=`uname -R | awk '{FS=".";print $4}' | sed s/\[m\|f\]//g`
MIPSPRO_MINOR_VERSION=`CC -version 2>&1 | awk '{FS=".";print $2}'`
if [ "$MIPSPRO_MINOR_VERSION" -gt "3" -a "$IRIX_VERSION" -ge "18" \
-a "$IRIX_VERSION" -le "22" ]; then
QMAKE_VARS="$QMAKE_VARS \"QMAKE_CXXFLAGS+=-LANG:libc_in_namespace_std=off\""
fi
;;
*)
IRIX_VERSION=-1
MIPSPRO_MINOR_VERSION=-1
;;
esac
# -----------------------------------------------------------------------------
# build qmake
# -----------------------------------------------------------------------------
# symlink includes
if [ -x "$relpath/bin/syncqt" ]; then
QTDIR=$relpath perl $relpath/bin/syncqt -inc $relpath/include
[ "$OPT_SHADOW" = "yes" ] && QTDIR=$relpath perl $relpath/bin/syncqt -inc $outpath/include
fi
if [ "$OPT_SHADOW" = "yes" ]; then
# we are doing a shadow build, so we need to use the includes from
# $outpath/include as well
QMAKE_VARS="$QMAKE_VARS \"INCLUDEPATH+=${outpath}/include\""
fi
# build qmake
if true; then ###[ '!' -f "$outpath/bin/tqmake" ];
echo "Creating qmake. Please wait..."
rm -f mkspecs/default
ln -s `echo $QMAKESPEC | 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
[ "$Edition" = "troll" ] && $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_CFLAGS="\$(QMAKE_CFLAGS)"
EXTRA_CXXFLAGS="\$(QMAKE_CXXFLAGS)"
EXTRA_LFLAGS="\$(QMAKE_LFLAGS)"
grep "^QMAKE_CC[^_A-Z0-9]" $QMAKESPEC/qmake.conf | sed "s,QMAKE_CC,CC," >>$mkfile
grep "^QMAKE_CXX[^_A-Z0-9]" $QMAKESPEC/qmake.conf | sed "s,QMAKE_CXX,CXX," >>$mkfile
grep "^QMAKE_CFLAGS[^_A-Z0-9]" $QMAKESPEC/qmake.conf >>$mkfile
grep "^QMAKE_CXXFLAGS[^_A-Z0-9]" $QMAKESPEC/qmake.conf | sed "s,\$\$QMAKE_CFLAGS,\$(QMAKE_CFLAGS)," >>$mkfile
grep "^QMAKE_LFLAGS[^_A-Z0-9]" $QMAKESPEC/qmake.conf >>$mkfile
if [ "$CFG_DEBUG" = "yes" ]; then
grep "QMAKE_CFLAGS_DEBUG[^_A-Z0-9]" $QMAKESPEC/qmake.conf >>$mkfile
grep "^QMAKE_CXXFLAGS_DEBUG[^_A-Z0-9]" $QMAKESPEC/qmake.conf | sed "s,\$\$QMAKE_CFLAGS_DEBUG,\$(QMAKE_CFLAGS_DEBUG)," >>$mkfile
EXTRA_CFLAGS="$EXTRA_CFLAGS \$(QMAKE_CFLAGS_DEBUG)"
EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS \$(QMAKE_CXXFLAGS_DEBUG)"
else
grep "QMAKE_CFLAGS_RELEASE[^_A-Z0-9]" $QMAKESPEC/qmake.conf >>$mkfile
grep "^QMAKE_CXXFLAGS_RELEASE[^_A-Z0-9]" $QMAKESPEC/qmake.conf | sed "s,\$\$QMAKE_CFLAGS_RELEASE,\$(QMAKE_CFLAGS_RELEASE)," >>$mkfile
EXTRA_CFLAGS="$EXTRA_CFLAGS \$(QMAKE_CFLAGS_RELEASE)"
EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS \$(QMAKE_CXXFLAGS_RELEASE)"
fi
if [ "$PLATFORM_MAC" = "yes" ]; then
echo "CARBON_LFLAGS +=-framework CoreServices" >>$mkfile
EXTRA_LFLAGS="$EXTRA_LFLAGS \$(CARBON_LFLAGS)"
EXTRA_CFLAGS="$EXTRA_CFLAGS \$(CARBON_CFLAGS) -DQT_MACOSX_VERSION=$QT_MAC_VERSION"
EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS \$(CARBON_CFLAGS) -DQT_MACOSX_VERSION=$QT_MAC_VERSION"
EXTRA_SOURCES="qurl.o qsettings_mac.o"
elif [ "$PLATFORM" = "tru64-cxx" ]; then
echo "OSF_LFLAGS = -lm" >>$mkfile
EXTRA_LFLAGS="$EXTRA_LFLAGS \$(OSF_LFLAGS)"
elif [ "$PLATFORM_QNX" = "yes" ]; then
echo "QNX_LFLAGS += -fhonor-std -fno-builtins -pipe" >>$mkfile
echo "QNX_CFLAGS += -lcpp" >>$mkfile
EXTRA_LFLAGS="$EXTRA_CFLAGS \$(QNX_LFLAGS)"
EXTRA_CFLAGS="$EXTRA_CFLAGS \$(QNX_CFLAGS)"
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
if [ "$MIPSPRO_MINOR_VERSION" -gt "3" \
-a "$IRIX_VERSION" -ge "18" -a "$IRIX_VERSION" -le "22" ]; then
EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS -LANG:libc_in_namespace_std=off"
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
sed -e "s,@SOURCE_PATH@,$relpath,g" -e "s,@BUILD_PATH@,$outpath,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_SOURCES,g" -e "s,@QMAKESPEC@,$QMAKESPEC,g" $in_mkfile >>$mkfile
if [ "$Edition" = "troll" ] &&
$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
fi
done
(cd $outpath/qmake; $MAKE || (echo "qmake failed to build. Aborting." && exit 2)) || exit 2
fi
# clean up temporary ntqconfig.h and ntqmodules.h
rm -f $outpath/include/qmake/ntqconfig.h
rm -f $outpath/include/qmake/ntqmodules.h
rmdir $outpath/include/qmake
#-------------------------------------------------------------------------------
# tests that need qmake
#-------------------------------------------------------------------------------
# work around broken X11 headers when using GCC 2.95 or later
if [ "$PLATFORM_X11" = "yes" ]; then
NOTYPE=no
$x11tests/notype.test $XQMAKESPEC $OPT_VERBOSE $relpath $outpath && NOTYPE=yes
[ $NOTYPE = "yes" ] && QMAKE_VARS="$QMAKE_VARS \"QMAKE_CXXFLAGS+=-fpermissive\""
fi
# find if the compiler supports enough of STL for our purposes
if [ $PLATFORM = "hpux-acc" -a "$CFG_STL" != "no" ]; then
echo
echo "As of aCC A.3.0.30 you may enable STL support in Qt by adding -AA"
echo "to the QMAKE_CXXFLAGS and QMAKE_LFLAGS variables in"
echo "$XQMAKESPEC/qmake.conf"
echo "and re-running configure. Make sure to use the -AA compiler switch"
echo "in all your software projects using Qt as it turns on the new C++"
echo "Standard Library which is not binary compatible with the old one."
echo
fi
if [ "$CFG_ENDIAN" = "auto" ]; then
if [ "$PLATFORM_MAC" = "yes" ]; then
true
elif $unixtests/endian.test $XQMAKESPEC $OPT_VERBOSE $relpath $outpath; then
CFG_ENDIAN="Q_LITTLE_ENDIAN"
else
CFG_ENDIAN="Q_BIG_ENDIAN"
fi
fi
if [ "$CFG_STL" = "auto" ]; then
if $unixtests/stl.test $XQMAKESPEC $OPT_VERBOSE $relpath $outpath; then
if [ "$CFG_STL" = "yes" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
echo "STL 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_STL=no
fi
else
CFG_STL=yes
fi
fi
# find if the platform supports IPv6
if [ "$CFG_IPV6" = "auto" ]; then
if $unixtests/ipv6.test $XQMAKESPEC $OPT_VERBOSE $relpath $outpath; then
if [ "$CFG_IPV6" = "yes" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
echo "IPv6 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_IPV6=no
fi
else
CFG_IPV6=yes
fi
fi
# find if the platform supports X/Open Large File compilation environment
if [ "$CFG_LARGEFILE" = "auto" ]; then
if $unixtests/largefile.test $XQMAKESPEC $OPT_VERBOSE $relpath $outpath; then
if [ "$CFG_LARGEFILE" = "yes" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
echo "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
else
CFG_LARGEFILE=yes
fi
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 " 4. 4bpp grayscale - also enables 8bpp"
echo " 8. 8bpp"
echo " 16. 16bpp"
echo " 24. 24bpp - also enables 32bpp"
echo " 32. 32bpp"
echo
echo "Each depth adds around 100Kb on 80386."
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
D4=;D8=;D16=;D24=;D32=
for D in `echo "$CFG_QWS_DEPTHS" | sed -e 's/,/ /g'`; do
case "$D" in
4) D4=y; D8=y
;; 8) D8=y
;; 16) D16=y
;; 24) D24=y; D32=y
;; 32) D32=y
esac
done
if [ -z "$D4" ]; then
QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_QWS_DEPTH_4"
fi
if [ -z "$D8" ]; then
QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_QWS_DEPTH_8"
fi
if [ -z "$D16" ]; then
QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_QWS_DEPTH_16"
fi
if [ -z "$D24" ]; then
QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_QWS_DEPTH_24"
fi
if [ -z "$D32" ]; then
QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_QWS_DEPTH_32"
fi
fi
# enable accessibility
if [ "$CFG_ACCESSIBILITY" = "yes" ]; then
QMAKE_CONFIG="$QMAKE_CONFIG accessibility"
fi
# update QMAKE_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
QMAKE_CONFIG="$QMAKE_CONFIG $c-config"
if [ "$CFG_QCONFIG" = $c ]; then
break;
fi
done
;;
*)
# not known to be sufficient for anything
if [ '!' -f $relpath/src/tools/qconfig-$CFG_QCONFIG.h ]; then
echo >&2 "No such configuration: $CFG_QCONFIG"
OPT_HELP=yes
fi
esac
# update QMAKE_CONFIG to show which modules are being built
for MODULE in $MODULES; do
if [ -d "$relpath/src/$MODULE" ]; then
M=`echo $MODULE | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
QMAKE_CONFIG="$QMAKE_CONFIG $MODULE"
fi
done
#-------------------------------------------------------------------------------
# ??? ### please add a title to this section
#-------------------------------------------------------------------------------
# build up the variables for output
QMAKE_OUTDIR=""
case $Products in
qt-enterprise)
QMAKE_CONFIG="$QMAKE_CONFIG enterprise"
;;
qt-internal)
# QMAKE_CONFIG="$QMAKE_CONFIG internal"
;;
*)
;;
esac
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 dll"
elif [ "$CFG_SHARED" = "no" ]; then
QMAKE_OUTDIR="${QMAKE_OUTDIR}-static"
QMAKE_CONFIG="$QMAKE_CONFIG staticlib"
fi
if [ "$CFG_THREAD" = "yes" ]; then
QMAKE_OUTDIR="${QMAKE_OUTDIR}-mt"
QMAKE_CONFIG="$QMAKE_CONFIG thread"
fi
if [ "$PLATFORM_QWS" = "yes" -o "$PLATFORM_QNX" = "yes" ]; then
QMAKE_OUTDIR="${QMAKE_OUTDIR}-emb-$CFG_EMBEDDED"
QMAKE_CONFIG="$QMAKE_CONFIG embedded"
rm -f src/.moc/$QMAKE_OUTDIR/allmoc.cpp # needs remaking if config changes
fi
QMAKE_VARS="$QMAKE_VARS \"QMAKE_INCDIR_QT=$relpath/include\""
QMAKE_VARS="$QMAKE_VARS \"QMAKE_LIBDIR_QT=$outpath/lib\""
QMAKE_VARS="$QMAKE_VARS \"QMAKE_RTLDIR_QT=$QT_INSTALL_LIBS\""
QMAKE_VARS="$QMAKE_VARS \"OBJECTS_DIR=.obj/$QMAKE_OUTDIR\" \"MOC_DIR=.moc/$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
[ "$CFG_PRECOMPILE" = "yes" ] && QMAKE_CONFIG="$QMAKE_CONFIG precompile_header"
if [ "$CFG_IPV6" = "no" ]; then
QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_IPV6"
else
QMAKE_CONFIG="$QMAKE_CONFIG ipv6"
fi
# don't add the link line if we build the image formats as a plugin
if [ "$CFG_LIBMNG" = "system" ]; then
QMAKE_CONFIG="$QMAKE_CONFIG system-mng"
if [ "$CFG_MNG" = "yes" ]; then
QMAKE_VARS="$QMAKE_VARS \"QMAKE_LIBS_QT+=-lmng\""
QMAKE_VARS="$QMAKE_VARS \"QMAKE_LIBS_QT_THREAD+=-lmng\""
fi
fi
if [ "$CFG_MNG" = "no" ]; then
QMAKE_CONFIG="$QMAKE_CONFIG no-mng"
elif [ "$CFG_MNG" = "yes" ]; then
QMAKE_CONFIG="$QMAKE_CONFIG mng"
fi
if [ "$CFG_LIBJPEG" = "system" ]; then
QMAKE_CONFIG="$QMAKE_CONFIG system-jpeg"
if [ "$CFG_JPEG" = "yes" ]; then
QMAKE_VARS="$QMAKE_VARS \"QMAKE_LIBS_QT+=-ljpeg\""
QMAKE_VARS="$QMAKE_VARS \"QMAKE_LIBS_QT_THREAD+=-ljpeg\""
fi
fi
if [ "$CFG_JPEG" = "no" ]; then
QMAKE_CONFIG="$QMAKE_CONFIG no-jpeg"
elif [ "$CFG_JPEG" = "yes" ]; then
QMAKE_CONFIG="$QMAKE_CONFIG jpeg"
fi
if [ "$CFG_LIBPNG" = "no" ]; then
CFG_PNG="no"
fi
if [ "$CFG_LIBPNG" = "system" ]; then
QMAKE_CONFIG="$QMAKE_CONFIG system-png"
if [ "$CFG_PNG" = "yes" ]; then
QMAKE_VARS="$QMAKE_VARS \"QMAKE_LIBS_QT+=-lpng\""
QMAKE_VARS="$QMAKE_VARS \"QMAKE_LIBS_QT_THREAD+=-lpng\""
fi
fi
if [ "$CFG_PNG" = "no" ]; then
QMAKE_CONFIG="$QMAKE_CONFIG no-png"
elif [ "$CFG_PNG" = "yes" ]; then
QMAKE_CONFIG="$QMAKE_CONFIG png"
fi
if [ "$CFG_GLIBMAINLOOP" = "no" ]; then
QMAKE_CONFIG="$QMAKE_CONFIG no-glibmainloop"
elif [ "$CFG_GLIBMAINLOOP" = "yes" ]; then
QMAKE_CONFIG="$QMAKE_CONFIG glibmainloop"
GLIB_CFLAGS="`pkg-config --cflags glib-2.0` `pkg-config --cflags gthread-2.0`"
QMAKE_VARS="$QMAKE_VARS \"QMAKE_CFLAGS_GLIB=$GLIB_CFLAGS\""
GLIB_LINKFLAG="`pkg-config --libs glib-2.0` `pkg-config --libs gthread-2.0`"
QMAKE_VARS="$QMAKE_VARS \"QMAKE_LIBS_GLIB=$GLIB_LINKFLAG\""
fi
if [ "$CFG_GIF" = "no" ]; then
QMAKE_CONFIG="$QMAKE_CONFIG no-gif"
elif [ "$CFG_GIF" = "yes" ]; then
QMAKE_CONFIG="$QMAKE_CONFIG gif"
fi
if [ "x$PLATFORM_MAC" = "xyes" ]; then
[ "$CFG_ZLIB" = "yes" ] && CFG_ZLIB="system"
fi
if [ "$CFG_ZLIB" = "no" ]; then
QMAKE_CONFIG="$QMAKE_CONFIG no-zlib"
QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_COMPRESS"
elif [ "$CFG_ZLIB" = "yes" ]; then
QMAKE_CONFIG="$QMAKE_CONFIG zlib"
elif [ "$CFG_ZLIB" = "system" ]; then
QMAKE_CONFIG="$QMAKE_CONFIG system-zlib"
QMAKE_VARS="$QMAKE_VARS \"QMAKE_LIBS_QT+=-lz\""
QMAKE_VARS="$QMAKE_VARS \"QMAKE_LIBS_QT_THREAD+=-lz\""
fi
[ "$CFG_NIS" = "yes" ] && QMAKE_CONFIG="$QMAKE_CONFIG nis"
[ "$CFG_CUPS" = "yes" ] && QMAKE_CONFIG="$QMAKE_CONFIG cups"
[ "$CFG_NAS" = "system" ] && QMAKE_CONFIG="$QMAKE_CONFIG nas"
[ "$CFG_BIG_CODECS" = "yes" ] && QMAKE_CONFIG="$QMAKE_CONFIG bigcodecs"
[ "$CFG_QWS_FREETYPE" = "yes" -a "x$CFG_EMBEDDED" != "xno" ] && QMAKE_CONFIG="$QMAKE_CONFIG ft"
if [ "$PLATFORM_X11" = "yes" ]; then
[ "$CFG_SM" = "yes" ] && QMAKE_CONFIG="$QMAKE_CONFIG x11sm"
# for some reason, the following libraries are not always build shared,
# so *every* program/lib (including Qt) has to link against them
if [ "$CFG_XSHAPE" = "yes" ]; then
QMAKE_CONFIG="$QMAKE_CONFIG xshape"
fi
if [ "$CFG_XINERAMA" = "yes" ]; then
QMAKE_CONFIG="$QMAKE_CONFIG xinerama"
QMAKE_VARS="$QMAKE_VARS \"QMAKE_LIBS_X11 = -lXinerama \$\$QMAKE_LIBS_X11\""
fi
if [ "$CFG_XCURSOR" = "yes" ]; then
QMAKE_CONFIG="$QMAKE_CONFIG xcursor"
QMAKE_VARS="$QMAKE_VARS \"QMAKE_LIBS_X11 = -lXcursor \$\$QMAKE_LIBS_X11\""
fi
if [ "$CFG_XRANDR" = "yes" ]; then
QMAKE_CONFIG="$QMAKE_CONFIG xrandr"
QMAKE_VARS="$QMAKE_VARS \"QMAKE_LIBS_X11 = -lXrandr \$\$QMAKE_LIBS_X11\""
fi
if [ "$CFG_XRENDER" = "yes" ]; then
QMAKE_CONFIG="$QMAKE_CONFIG xrender"
QMAKE_VARS="$QMAKE_VARS \"QMAKE_LIBS_X11 = -lXrender \$\$QMAKE_LIBS_X11\""
fi
if [ "$CFG_FREETYPE" = "yes" ]; then
QMAKE_CONFIG="$QMAKE_CONFIG xftfreetype"
fi
if [ "$CFG_TABLET" = "yes" ]; then
QMAKE_CONFIG="$QMAKE_CONFIG tablet"
QMAKE_VARS="$QMAKE_VARS \"QMAKE_LIBS_X11 = -lXi \$\$QMAKE_LIBS_X11\""
fi
if [ "$CFG_XKB" = "yes" ]; then
QMAKE_CONFIG="$QMAKE_CONFIG xkb"
fi
if [ "$CFG_IM" = "yes" ]; then
QMAKE_CONFIG="$QMAKE_CONFIG inputmethod"
elif [ "$CFG_IM" = "no" ]; then
QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_IM"
fi
if [ "$CFG_IM_EXT" = "yes" ]; then
QMAKE_CONFIG="$QMAKE_CONFIG inputmethod-ext"
elif [ "$CFG_IM_EXT" = "no" ]; then
QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_IM_EXTENSIONS"
fi
elif [ "$PLATFORM_MAC" = "yes" ]; then
if [ "$CFG_TABLET" = "yes" ]; then
QMAKE_CONFIG="$QMAKE_CONFIG tablet"
fi
fi
[ '!' -z "$D_FLAGS" ] && QMAKE_VARS="$QMAKE_VARS \"DEFINES+=$D_FLAGS\""
[ '!' -z "$L_FLAGS" ] && QMAKE_VARS="$QMAKE_VARS \"QMAKE_LIBDIR_FLAGS+=$L_FLAGS\""
[ '!' -z "$l_FLAGS" ] && QMAKE_VARS="$QMAKE_VARS \"LIBS+=$l_FLAGS\""
if [ '!' -z "$R_FLAGS" ]; then
if grep QMAKE_RPATH $XQMAKESPEC/qmake.conf >/dev/null; then
echo # Using -R/-rpath, so no need to warn
else
echo
echo "ERROR: -R cannot be used on this platform as \$QMAKE_RPATH is"
echo " undefined."
echo
exit 1
fi
QMAKE_VARS="$QMAKE_VARS \"QMAKE_LFLAGS+=$R_FLAGS\""
fi
if [ '!' -z "$I_FLAGS" ]; then
QMAKE_VARS="$QMAKE_VARS \"QMAKE_CFLAGS+=$I_FLAGS\""
QMAKE_VARS="$QMAKE_VARS \"QMAKE_CXXFLAGS+=$I_FLAGS\""
fi
# install things
QMAKE_VARS="$QMAKE_VARS \"QT_INSTALL_PREFIX=${QT_INSTALL_PREFIX}\""
QMAKE_VARS="$QMAKE_VARS \"docs.path=${QT_INSTALL_DOCS}\""
QMAKE_VARS="$QMAKE_VARS \"headers.path=${QT_INSTALL_HEADERS}\""
QMAKE_VARS="$QMAKE_VARS \"plugins.path=${QT_INSTALL_PLUGINS}\""
QMAKE_VARS="$QMAKE_VARS \"libs.path=${QT_INSTALL_LIBS}\""
QMAKE_VARS="$QMAKE_VARS \"bins.path=${QT_INSTALL_BINS}\""
QMAKE_VARS="$QMAKE_VARS \"data.path=${QT_INSTALL_DATA}\""
QMAKE_VARS="$QMAKE_VARS \"translations.path=${QT_INSTALL_TRANSLATIONS}\""
# turn off exceptions for the compilers that support it
COMPILER=`echo $PLATFORM | cut -f 2- -d-`
if [ "$CFG_EXCEPTION_SUPPORT" = "no" ]; then
case "$COMPILER" in
g++*)
QMAKE_VARS="$QMAKE_VARS \"QMAKE_CFLAGS+=-fno-exceptions\""
QMAKE_VARS="$QMAKE_VARS \"QMAKE_CXXFLAGS+=-fno-exceptions\""
QMAKE_VARS="$QMAKE_VARS \"QMAKE_LFLAGS+=-fno-exceptions\""
;;
cc*)
case "$PLATFORM" in
irix-cc*)
QMAKE_VARS="$QMAKE_VARS \"QMAKE_CFLAGS+=-LANG:exceptions=off\""
QMAKE_VARS="$QMAKE_VARS \"QMAKE_CXXFLAGS+=-LANG:exceptions=off\""
QMAKE_VARS="$QMAKE_VARS \"QMAKE_LFLAGS+=-LANG:exceptions=off\""
;;
*) ;;
esac
;;
*) ;;
esac
fi
#-------------------------------------------------------------------------------
# part of configuration information goes into ntqmodules.h
#-------------------------------------------------------------------------------
rm -f $outpath/include/ntqmodules.h.new
cat >$outpath/include/ntqmodules.h.new << EOF
/* These modules are present in this configuration of Qt */
EOF
for MODULE in $MODULES; do
if [ -d "$relpath/src/$MODULE" ]; then
M=`echo $MODULE | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
echo "#define TQT_MODULE_$M" >>$outpath/include/ntqmodules.h.new
fi
done
# avoid unecessary rebuilds by copying only if ntqmodules.h has changed
if cmp -s $outpath/include/ntqmodules.h $outpath/include/ntqmodules.h.new; then
rm -f $outpath/include/ntqmodules.h.new
else
[ -f $outpath/include/ntqmodules.h ] && chmod +w $outpath/include/ntqmodules.h
mv -f $outpath/include/ntqmodules.h.new $outpath/include/ntqmodules.h
chmod -w $outpath/include/ntqmodules.h
fi
#-------------------------------------------------------------------------------
# generate TQT_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++
QMAKE_CONF_COMPILER=`grep "QMAKE_CXX[^_A-Z0-9a-z]" $QMAKESPEC/qmake.conf | sed "s,.* *= *\(.*\)$,\1,"`
COMPILER_VERSION=`${QMAKE_CONF_COMPILER} --version 2>/dev/null | sed 's,^[^0-9]*,,g'`
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
# QMAKE_CONFIG can contain the following:
#
# Things that affect the Qt API/ABI:
#
# Options:
# minimal-config small-config medium-config large-config full-config
#
# Modules:
# styles tools kernel widgets dialogs iconview workspace inputmethod
#
# Enterprise/Open Source edition modules:
# network canvas table xml opengl sql
#
# Options:
# stl
#
# X11 : inputmethod-ext
#
# Things that do not affect the Qt API/ABI:
# system-jpeg no-jpeg jpeg
# system-mng no-mng mng
# system-png no-png png
# system-zlib no-zlib zlib
# no-gif gif
# debug release
# dll staticlib
#
# internal
# nocrosscompiler
# enterprise
# thread
# GNUmake
# largefile
# nis
# nas
# bigcodecs
# tablet
# ipv6
#
# X11 : xftnameunparse x11sm xinerama xcursor xrandr xrender xftfreetype xkb inputmethod
# Embedded: embedded ft
#
ALL_OPTIONS="styles tools kernel widgets dialogs iconview workspace inputmethod network canvas table xml opengl sql stl"
BUILD_CONFIG=
BUILD_OPTIONS=
# determine the build options
for config_option in $QMAKE_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"
;;
styles|tools|kernel|widgets|dialogs|iconview|workspace|inputmethod|network|canvas|table|xml|opengl|sql|stl)
# these config options affect the Qt API/ABI. they should influence
# the generation of the buildkey, so we don't skip them
SKIP="no"
;;
*) # 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
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 TQT_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"
TQT_BUILD_KEY="$CFG_USER_BUILD_KEY $UNAME_MACHINE $UNAME_SYSTEM $COMPILER $BUILD_OPTIONS"
# strip out leading/trailing/extra whitespace
TQT_BUILD_KEY=`echo $TQT_BUILD_KEY | sed -e "s, *, ,g" -e "s,^ *,," -e "s, *$,,"`
#-------------------------------------------------------------------------------
# part of configuration information goes into ntqconfig.h
#-------------------------------------------------------------------------------
case "$CFG_QCONFIG" in
full)
echo "/* Everything */" >$outpath/include/ntqconfig.h.new
;;
*)
QCONFIGFILE=qconfig-$CFG_QCONFIG.h
echo "/* Copied from $QCONFIGFILE */" >$outpath/include/ntqconfig.h.new
cat $relpath/src/tools/$QCONFIGFILE >>$outpath/include/ntqconfig.h.new
;;
esac
cat >> $outpath/include/ntqconfig.h.new <<EOF
/* License information */
#define QT_PRODUCT_LICENSEE "$Licensee"
#define QT_PRODUCT_LICENSE "$Products"
/* Build key */
#define TQT_BUILD_KEY "$TQT_BUILD_KEY"
/* Machine byte-order */
#define Q_BIG_ENDIAN 4321
#define Q_LITTLE_ENDIAN 1234
EOF
if [ "$CFG_ENDIAN" = "auto" ]; then
cat >> $outpath/include/ntqconfig.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
# message "Unable to determine byte order!"
#endif
EOF
else
echo "#define Q_BYTE_ORDER $CFG_ENDIAN" >> $outpath/include/ntqconfig.h.new
fi
cat >> $outpath/include/ntqconfig.h.new << EOF
/* Compile time features */
EOF
[ '!' -z "$LicenseKey" ] && echo "#define QT_PRODUCT_LICENSEKEY \"$LicenseKey\"" >>$outpath/include/ntqconfig.h.new
if [ "$CFG_LARGEFILE" = "yes" ]; then
echo "#define QT_LARGEFILE_SUPPORT 64" >>$outpath/include/ntqconfig.h.new
if [ "$CFG_NEWABI" = "yes" ]; then
echo "#define QT_ABI_QT4 1" >>$outpath/include/ntqconfig.h.new
fi
fi
$unixtests/ptrsize.test $XQMAKESPEC $OPT_VERBOSE $relpath $outpath
echo "#define TQT_POINTER_SIZE $?" >>$outpath/include/ntqconfig.h.new
if [ ! -z "$QT_MAC_VERSION" ]; then
echo "#define QT_MACOSX_VERSION ${QT_MAC_VERSION} /*from config.tests*/" >>$outpath/include/ntqconfig.h.new
fi
## find excluded styles and add this to $QCONFIG_FLAGS
VSTYLE=no
VNO=no
for QMVAR in $QMAKE_VARS; do
STRIPPED=`echo $QMVAR | sed 's,^",,' | sed 's,"$,,'`
if [ "$VSTYLE" = "yes" ]; then
if [ "$VNO" = "yes" ]; then
NOSTYLE=`echo $STRIPPED | tr '[:lower:]' '[:upper:]'`
QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_STYLE_$NOSTYLE"
VSTYLE=no
VNO=no
else
if [ "$STRIPPED" = "-=" ]; then
VNO=yes
else
VSTYLE=no
fi
fi
else
if [ "$STRIPPED" = "styles" ]; then
VSTYLE=yes
fi
fi
done
if [ -n "$QCONFIG_FLAGS" ]; then
for cfg in $QCONFIG_FLAGS; do
cat >>$outpath/include/ntqconfig.h.new << EOF
#ifndef $cfg
# define $cfg
#endif
EOF
done
fi
# avoid unecessary rebuilds by copying only if ntqconfig.h has changed
if cmp -s $outpath/include/ntqconfig.h $outpath/include/ntqconfig.h.new; then
rm -f $outpath/include/ntqconfig.h.new
else
[ -f $outpath/include/ntqconfig.h ] && chmod +w $outpath/include/ntqconfig.h
mv $outpath/include/ntqconfig.h.new $outpath/include/ntqconfig.h
chmod -w $outpath/include/ntqconfig.h
fi
#-------------------------------------------------------------------------------
# save configuration into .qmake.cache
#-------------------------------------------------------------------------------
CACHEFILE=$outpath/.qmake.cache
[ -f $CACHEFILE.tmp ] && rm -f $CACHEFILE.tmp
cat >>$CACHEFILE.tmp <<EOF
CONFIG += $QMAKE_CONFIG dylib create_prl link_prl
QMAKESPEC = $XPLATFORM
QT_SOURCE_TREE = $relpath
QT_BUILD_TREE = $outpath
QMAKE_ABSOLUTE_SOURCE_ROOT = \$\$QT_SOURCE_TREE
EOF
# cmdline args
quoted=no
tmp=""
for i in $QMAKE_VARS; do
if [ "$quoted" = "no" ]; then
case "$i" in
\"*\") echo $i | sed 's,^",,' | sed 's,"$,,' >>$CACHEFILE.tmp ;;
\"*) quoted=yes ; tmp=$i ;;
*) echo $i >>$CACHEFILE.tmp ;;
esac
else
case "$i" in
*\") quoted=no
echo $tmp $i | sed 's,^",,' | sed 's,"$,,' >>$CACHEFILE.tmp
tmp="" ;;
*) tmp="$tmp $i" >>$CACHEFILE.tmp ;;
esac
fi
done
# incrementals
INCREMENTAL=""
[ "$CFG_INCREMENTAL" = "auto" ] && $WHICH p4 >/dev/null 2>&1 && [ "$Edition" = "troll" ] && CFG_INCREMENTAL="yes"
if [ "$CFG_INCREMENTAL" = "yes" ]; then
openfiles=`find $relpath -perm u+w -mtime -3 | grep 'cpp$'`
for f in $openfiles; 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_EXCEPTION_SUPPORT" != "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 library 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 should continue to work.
EOF
fi
;;
cc*)
case "$PLATFORM" in
irix-cc*)
if [ "$CFG_EXCEPTION_SUPPORT" != "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
echo
if [ "$XPLATFORM" = "$PLATFORM" ]; then
echo "Build type: $PLATFORM"
else
echo "Building on: $PLATFORM"
echo "Building for: $XPLATFORM"
fi
if [ -n "$PLATFORM_NOTES" ]; then
echo "Platform notes:"
echo "$PLATFORM_NOTES"
else
echo
fi
if [ "$OPT_VERBOSE" = "yes" ]; then
echo "qmake vars ...... $QMAKE_VARS"
echo "qmake switches .. $QMAKE_SWITCHES"
fi
[ "$OPT_CONCURRENT" != "0" ] && echo "Concurrent .......... $OPT_CONCURRENT"
[ "$CFG_INCREMENTAL" = "yes" ] && [ '!' -z "$INCREMENTAL" ] && echo "Incremental ......... $INCREMENTAL"
echo "Configuration ....... $QMAKE_CONFIG"
echo "STL support ......... $CFG_STL"
echo "PCH support ......... $CFG_PRECOMPILE"
echo "IPv6 support ........ $CFG_IPV6"
echo "Thread support ...... $CFG_THREAD"
echo "NIS support ......... $CFG_NIS"
echo "CUPS support ........ $CFG_CUPS"
if [ "$CFG_LARGEFILE" = "yes" ]; then
echo "Large File support .. partial"
else
echo "Large File support .. $CFG_LARGEFILE"
fi
echo "GIF support ......... $CFG_GIF"
if [ "$CFG_MNG" = "no" ]; then
echo "MNG support ......... $CFG_MNG"
else
echo "MNG support ......... $CFG_MNG ($CFG_LIBMNG)"
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_GLIBMAINLOOP" = "no" ]; then
echo "Glib main loop support ......... $CFG_GLIBMAINLOOP"
else
echo "Glib main loop support ......... $CFG_GLIBMAINLOOP ($CFG_LIBGLIBMAINLOOP)"
fi
echo "zlib support ........ $CFG_ZLIB"
if [ "$PLATFORM_QWS" = "yes" ]; then
echo "Embedded support .... $CFG_EMBEDDED"
else
if echo $MODULES | grep opengl >/dev/null; then
opengl=yes
else
opengl=no
fi
echo "OpenGL support ...... $opengl"
fi
if [ "$PLATFORM_X11" = "yes" ]; then
echo "NAS sound support ... $CFG_NAS"
echo "Session management .. $CFG_SM"
echo "XShape support ...... $CFG_XSHAPE"
echo "Xinerama support .... $CFG_XINERAMA"
echo "Tablet support ...... $CFG_TABLET"
echo "Xcursor support ..... $CFG_XCURSOR"
echo "XRandR support ...... $CFG_XRANDR"
echo "XRender support ..... $CFG_XRENDER"
echo "Xft support ......... $CFG_FREETYPE"
echo "XKB Support ......... $CFG_XKB"
echo "immodule support .... $CFG_IM"
echo "immodule ext support $CFG_IM_EXT"
elif [ "$PLATFORM_MAC" = "yes" ]; then
echo "Accessibility ....... $CFG_ACCESSIBILITY"
echo "Tablet support ...... $CFG_TABLET"
fi
# complain about not being able to use plugins if we are using a static build
if [ "$CFG_SHARED" = "no" ]; then
echo
echo "WARNING: Using static linking will disable the use of plugins."
echo "Make sure you compile ALL needed modules into the library."
echo
fi
echo
sepath=`echo $relpath | sed -e 's/\\./\\\\./g'`
PROCS=1
EXEC=""
#-------------------------------------------------------------------------------
# build makefiles based on the configuration
#-------------------------------------------------------------------------------
echo "Finding project files. Please wait..."
if [ -z "$QMAKE_PROJECTS" ]; then
QMAKE_PROJECTS=`find $relpath/. -name '.pc' -prune -o -name '*.pro' -print | sed 's-/\./-/-'`
else
QT_PROJECTS=
for a in `echo $QMAKE_PROJECTS`; do
put_in="$a"
for leave_out in `echo $QMAKE_IGNORE_PROJECTS`; do
if [ "$put_in" = "$leave_out" ]; then
put_in=
break;
fi
done
[ ! -z "$put_in" ] && QT_PROJECTS="$QT_PROJECTS $put_in"
done
if [ -e "${relpath}/projects.pro" ]; then
for mkfile in "${outpath}/Makefile" "${outpath}/GNUmakefile"; do
[ -f "$mkfile" ] && chmod +w "$mkfile"
$outpath/bin/tqmake "QT_PROJECTS=$QT_PROJECTS" ${relpath}/projects.pro -o $mkfile
done
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
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 == "qt" || \$3 == "moc" ) {
target_file = first
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
for p in `echo $QMAKE_IGNORE_PROJECTS`; do
if [ -f .projects ]; then
grep -v $p .projects > .tmp
mv -f .tmp .projects
fi
if [ -f .projects.3 ]; then
grep -v $p .projects.3 > .tmp
mv -f .tmp .projects.3
fi
done
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
echo "Creating makefiles. Please wait..."
for file in .projects .projects.3; do
[ '!' -f "$file" ] && continue
for a in `cat $file`; do
case $a in
*-kde.pro|*qtmain.pro) continue ;;
*/qmake/qmake.pro) continue ;;
*projects.pro) continue ;;
*-pro.pro)
[ "x$Edition" != "xpro" ] && continue
;;
*moc*) SPEC=$QMAKESPEC ;;
*) SPEC=$XQMAKESPEC ;;
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
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.
all clean install qmake Makefile: FORCE
$outpath/bin/tqmake $QMAKE_SWITCHES $QMAKE_SPEC_ARGS -o $OUTDIR $a
cd $OUTDIR
\$(MAKE) \$@
FORCE:
EOF
else
EXEC="$outpath/bin/tqmake $QMAKE_SWITCHES $QMAKE_SPEC_ARGS -o $OUTDIR $a"
if [ "$OPT_VERBOSE" = "yes" ]; then
echo " (`basename $SPEC`)"
if echo '\c' | grep '\c' >/dev/null; then
echo -n "$EXEC"
else
echo "$EXEC\c"
fi
fi
echo
[ -f "${OUTDIR}/Makefile" ] && chmod +w ${OUTDIR}/Makefile
if [ "$OPT_CONCURRENT" = "0" ] || [ "$OPT_CONCURRENT" = "1" ]; then
/bin/sh -c "$EXEC"
else
/bin/sh -c "$EXEC" &
if [ "$PROCS" != "$OPT_CONCURRENT" ]; then
PROCS=`expr $PROCS + 1`
else
PROCS=1
[ "$OPT_VERBOSE" = "yes" ] && echo "Waiting.."
wait #wait for the processes to end
fi
fi
fi
done
done
rm -f .projects .projects.3
#Special Qt/Mac thing. We bootched permissions in Qt 3.3.0 beta 1.
#This is probably the only easy place to detect and remove it ourselves
if [ "$PLATFORM_MAC" = "yes" ]; then
if [ -d /Library/Qt ]; then
lslad=`ls -lad /Library/Qt | grep '^d......rwx'`
if [ -z "$lslad" ]; then
echo
removed=no
rm -rf /Library/Qt && removed=yes
if [ "$removed" = "no" ]; then
cat <<EOF
The directory '/Library/Qt' has incorrect permissions and configure could
not fix it automatically. Please remove this direcotry by hand.
EOF
fi
fi
fi
fi
#-------------------------------------------------------------------------------
# finally save the executed command to another script
#-------------------------------------------------------------------------------
if [ `basename $0` != "config.status" ]; then
[ -f $outpath/config.status ] && rm -f $outpath/config.status
echo "#!/bin/sh" >$outpath/config.status
echo "if [ \"\$#\" -gt 0 ]; then" >>$outpath/config.status
echo " echo yes | $relpath/$relconf $OPT_CMDLINE \"\$@\"" >>$outpath/config.status
echo "else" >>$outpath/config.status
echo " echo yes | $relpath/$relconf $OPT_CMDLINE" >>$outpath/config.status
echo "fi" >>$outpath/config.status
chmod +x $outpath/config.status
fi
echo
echo Qt is now configured for building. Just run $MAKE.
echo To reconfigure, run $MAKE confclean and configure.
echo
View Git Blame Copy Permalink