#!/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


#-------------------------------------------------------------------------------
# check commercial license
#-------------------------------------------------------------------------------

# Qtopia Edition.
if [ -f $relpath/LICENSE.Qtopia ]; then
    Edition="qtopia"
    Licensee="Qtopia"
    Products="qt-enterprise"
# Open Source Edition - may only be used under the terms of the QPL or GPL.
# Qt/X11, Qt/Embedded
elif [ -f $relpath/LICENSE.QPL -o -f $relpath/LICENSE.GPL2 -o -f $relpath/LICENSE.GPL3 ]; then
    [ "$PLATFORM_MAC" = "maybe" ] && PLATFORM_MAC=yes
    [ "$PLATFORM_QWS" = "maybe" ] && PLATFORM_QWS=yes
    Edition="free"
    Licensee="Free"
    Products="qt-free"
# Evaluation version.
# Qt/X11, Qt/Embedded, Qt/Mac
elif [ -f $relpath/LICENSE.EVAL ]; then
    [ "$PLATFORM_QWS" = "maybe" ] && PLATFORM_QWS=yes
    Edition="eval"
    Licensee="Evaluation"
    Products="qt-eval"
# Internal Trolltech edition.
# Qt/X11, Qt/Embedded, Qt/Mac, Qt/QNX
elif [ -f $relpath/LICENSE.TROLL ]; then
    [ "$PLATFORM_MAC" = "maybe" ] && PLATFORM_MAC=yes
    [ "$PLATFORM_QNX" = "maybe" ] && PLATFORM_QNX=yes
    Edition="troll"
    Licensee="Trolltech"
    Products="qt-internal"
# Commercial edition - needs a license.
# Qt/X11, Qt/Embedded, Qt/Mac
elif [ -f $relpath/.LICENSE ]; then
    [ "$PLATFORM_MAC" = "maybe" ] && PLATFORM_MAC=yes
    [ "$PLATFORM_QWS" = "maybe" ] && PLATFORM_QWS=yes
    echo
    Desc=""
    if [ -f $HOME/.qt-license ]; then
	. $HOME/.qt-license >/dev/null 2>&1
	if [ -z "$LicenseKey" ]; then
	    echo
	    echo "You are using an old license file."
	    echo
	    echo "Please install the license file supplied by Trolltech,"
	    echo "or install the Qt Open Source Edition if you intend to develop"
	    echo "open source software."
	    exit 1
	fi
    else
	if [ -z "$LicenseKey" ]; then
	    echo
	    if echo '\c' | grep '\c' >/dev/null; then
		echo -n "Please enter your license key: "
	    else
		echo "Please enter your license key: \c"
	    fi
	    read LicenseKey
	fi
    fi
    if echo $LicenseKey | grep "....-....-...." >/dev/null 2>&1; then
	# get the first character of the key
	keyTest=`echo $LicenseKey | cut -b1`
	# this character should fit the platform
	if [ "$PLATFORM_QWS" = "yes" ]; then
	    case $keyTest in
	    A|B|C|D|E|F|G|H|a|b|c|d|e|f|g|h)
		# Qt/Embedded
		echo
		;;
	    *)
		echo
		echo "You are not licensed for the Qt/Embedded platform."
		echo
		echo "Please contact sales@trolltech.com to upgrade your license"
		echo "to include the Qt/Embedded platform, or install the"
		echo "Qt Open Source Edition if you intend to develop open source"
		echo "software."
		exit 1
		;;
	    esac
	elif [ "$PLATFORM_MAC" = "yes" ]; then
	    case $keyTest in
	    *) ###
		# Qt/Mac
		echo
		;;
	    *)
		echo
		echo "You are not licensed for the Qt/Mac platform."
		echo
		echo "Please contact sales@trolltech.com to upgrade your license"
		echo "to include the Qt/Mac platform."
		exit 1
		;;
	    esac
	else
	    case $keyTest in
	    6|7|8|9|E|F|G|H|e|f|g|h)
		# Qt/X11
		echo
		;;
	    *)
		echo
		echo "You are not licensed for the Qt/X11 platform."
		echo
		echo "Please contact sales@trolltech.com to upgrade your license to"
		echo "include the Qt/X11 platform, or install the Qt Open Source Edition"
		echo "if you intend to develop open source software."
		exit 1
		;;
	    esac
	fi
	case $keyTest in
	4|5|8|9|C|D|G|H|c|d|g|h)
	    # Enterprise
	    Products=qt-enterprise
	    Desc="Enterprise"
	    Edition="ent"
	    ;;
	*)
	    # Professional
	    Products=qt-professional
	    Desc="Professional"
	    Edition="pro"
	    ;;
	esac
	case $keyTest in
	3|5|7|9|B|D|F|H|b|d|f|h)
	    # US
	    cp -f $relpath/.LICENSE-US $relpath/LICENSE
	    ;;
	*)
	    cp -f $relpath/.LICENSE $relpath/LICENSE
	    ;;
	esac
    else
	echo
	echo "Invalid license key. Please check the license key."
	exit 1
    fi
else
    echo "The LICENSE, LICENSE.QPL, or LICENSE.GPL2 file shipped with"
    echo "this software has disappeared."
    echo
    echo "Sorry, you are not licensed to use this software."
    echo "Try re-installing."
    echo
    exit 1
fi

# licensed modules depend on type of commercial license
MODULES="styles tools kernel widgets dialogs iconview workspace inputmethod"
[ "$PLATFORM_QWS" = "yes" ] && [ "$Products" = "qt-professional" ] && MODULES="$MODULES network"
[ "$Products" != "qt-professional" ] && MODULES="$MODULES 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=qt
CFG_JPEG=auto
CFG_LIBJPEG=qt
CFG_MNG=auto
CFG_LIBMNG=qt
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
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)
	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
	;;
    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 */

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 *qInstallPath()             { return QT_INSTALL_PREFIX       + 11; }
const char *qInstallPathDocs()         { return QT_INSTALL_DOCS         + 11; }
const char *qInstallPathHeaders()      { return QT_INSTALL_HEADERS      + 11; }
const char *qInstallPathLibs()         { return QT_INSTALL_LIBS         + 11; }
const char *qInstallPathBins()         { return QT_INSTALL_BINS         + 11; }
const char *qInstallPathPlugins()      { return QT_INSTALL_PLUGINS      + 11; }
const char *qInstallPathData()         { return QT_INSTALL_DATA         + 11; }
const char *qInstallPathTranslations() { return QT_INSTALL_TRANSLATIONS + 11; }
const char *qInstallPathSysconf()      { 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 qconfig.h and qmodules.h)
[ -d $outpath/include/qmake ] || mkdir -p $outpath/include/qmake

# create temporary qconfig.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/qconfig.h <<EOF
/* All features enabled while building qmake */
EOF

# create temporary qmodules.h for compiling qmake
cat >>$outpath/include/qmake/qmodules.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/moc\""
QMAKE_VARS="$QMAKE_VARS \"QMAKE_UIC=$outpath/bin/uic -L \$\$QT_BUILD_TREE/plugins\""
QMAKE_VARS="$QMAKE_VARS \"QMAKE_QMAKE=$outpath/bin/qmake\""
# 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-libjpeg] [-system-libjpeg] [-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/qgif.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-libjpeg ........ Use the libjpeg bundled with Qt.
    -system-libjpeg .... Use jpeglib from the operating system.
			 See http://www.ijg.org

 *  -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 Qt3).

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, INTERACTIVE PART
# -----------------------------------------------------------------------------

# check for license confirmation
if [ "$Edition" = "qtopia" ]; then
    if [ "$PLATFORM_X11" = "yes" ]; then
	Platform="Qt/X11"
    else
	echo
	echo "Internal error: unknown platform."
	echo
	exit 2
    fi
    TheLicense=`head -n 1 $relpath/LICENSE.Qtopia`
    while true; do
        echo
        echo "This is the $Platform Qtopia Edition."
        echo
        echo "You are licensed to use this software under the terms of"
        echo "the $TheLicense."
        echo
        echo "Type '?' to view the $TheLicense."
        echo "Type 'yes' to accept this license offer."
        echo "Type 'no' to decline this license offer."
        echo
        if echo '\c' | grep '\c' >/dev/null; then
            echo -n "Do you accept the terms of the $TheLicense? "
        else
            echo "Do you accept the terms of the $TheLicense? \c"
        fi
        read acceptance
        echo
	if [ "$acceptance" = yes ]; then
	    break
	else
	    if [ "$acceptance" = no ]; then
		echo "You are not licensed to use this software."
		echo
		exit 0
	    elif [ "$acceptance" = "?" ]; then
		more $relpath/LICENSE.Qtopia
	    fi
	fi
    done
elif [ "$Edition" = "free" ]; then
    while true; do
	if [ "$PLATFORM_QWS" = "yes" ]; then
	    echo
	    echo "This is the Qt/Embedded Open Source Edition."
	    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
	    affix="the"
	elif [ "$PLATFORM_MAC" = "yes" ]; then
	    echo
	    echo "This is the Qt/Mac Open Source Edition."
	    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
	    affix="the"
	elif [ "$PLATFORM_X11" = "yes" ]; then
	    echo
	    echo "This is the Qt/X11 Open Source Edition."
	    echo
	    echo "You are licensed to use this software under the terms of either"
	    echo "the Q Public License (QPL) or the GNU General Public License (GPL)"
	    echo "versions 2 or 3."
	    echo
	    echo "Type 'Q' to view the Q Public License."
	    affix="either"
	else
	    echo
	    echo "Internal error."
	    echo
	    exit 2
	fi
	echo "Type '2' to view the GNU General Public License version 2."
	echo "Type '3' to view the GNU General Public License version 3."
	echo "Type 'yes' to accept this license offer."
	echo "Type 'no' to decline this license offer."
	echo
	if echo '\c' | grep '\c' >/dev/null; then
	    echo -n "Do you accept the terms of $affix license? "
	else
	    echo "Do you accept the terms of $affix license? \c"
	fi
	read acceptance
	echo
	if [ "$acceptance" = "yes" ]; then
	    break
	elif [ "$acceptance" = "no" ]; then
	    echo "You are not licensed to use this software."
	    echo
	    exit 0
	elif [ "$acceptance" = "2" ]; then
	    more $relpath/LICENSE.GPL2
	elif [ "$acceptance" = "3" ]; then
	    more $relpath/LICENSE.GPL3
	elif [ "$acceptance" = "Q" -o "$acceptance" = "q" ]; then
	    if [ "$PLATFORM_QWS" != "yes" ]; then
		more $relpath/LICENSE.QPL
	    fi
	fi
    done
elif [ "$Edition" = "eval" ]; then
    while true; do
	if [ "$PLATFORM_QWS" = "yes" ]; then
	    echo
	    echo "This is the Qt/Embedded Evaluation version."
	    echo
	elif [ "$PLATFORM_X11" = "yes" ]; then
	    echo
	    echo "This is the Qt/X11 Evaluation version."
	    echo
	else
	    echo >&2
	    echo "Internal error." >&2
	    echo >&2
	    exit 2
	fi
	echo "You are licensed to use this software under the terms of"
	echo "the Qt EVALUATION VERSION LICENSE AGREEMENT"
	echo
	echo "Type '?' to view the Evaluation License."
	echo "Type 'yes' to accept this license offer."
	echo "Type 'no' to decline this license offer."
	echo
	if echo '\c' | grep '\c' >/dev/null; then
	    echo -n "Do you accept the terms of the license? "
	else
	    echo "Do you accept the terms of the license? \c"
	fi
	read acceptance
	echo
	if [ "$acceptance" = "yes" ]; then
	    break
	elif [ "$acceptance" = "no" ] ;then
	    echo "You are not licensed to use this software."
	    echo
	    exit 0
	elif [ "$acceptance" = "?" ]; then
	    more $relpath/LICENSE.EVAL
	fi
    done
elif [ "$Edition" = "troll" ]; then
    if [ "$PLATFORM_QNX" = "yes" ]; then
	Platform="Qt/QNX"
    elif [ "$PLATFORM_QWS" = "yes" ]; then
	Platform="Qt/Embedded"
    elif [ "$PLATFORM_MAC" = "yes" ]; then
	Platform="Qt/Mac"
    elif [ "$PLATFORM_X11" = "yes" ]; then
	Platform="Qt/X11"
    else
	echo
	echo "Internal error: unknown platform."
	echo
	exit 2
    fi
    echo
    echo "This is the Trolltech in-house version of $Platform."
    echo
else
    if [ -f $HOME/.qt-license ]; then
	ExpiryDate=`echo $ExpiryDate | sed -e "s,-,,g" | tr -d "\n\r"`
	[ -z "$ExpiryDate" ] && ExpiryDate="0"
	Today=`date +%Y%m%d`
	if [ "$Today" -gt "$ExpiryDate" ]; then
	    echo
	    echo "WARNING  WARNING  WARNING  WARNING"
	    echo
	    echo "  Your support and upgrade period has expired."
	    echo
	    echo "  You may continue to use your last licensed release"
	    echo "  of Qt under the terms of your existing license"
	    echo "  agreement. But you are not entitled to technical"
	    echo "  support, nor are you entitled to use any more recent"
	    echo "  Qt releases."
	    echo
	    echo "  Please contact sales@trolltech.com to renew your"
	    echo "  support and upgrades for this license."
	    echo
	    echo "WARNING  WARNING  WARNING  WARNING"
	    echo
	    sleep 3
	fi
    fi
    if [ "$PLATFORM_QWS" = "yes" ]; then
	Platform="Qt/Embedded"
    elif [ "$PLATFORM_MAC" = "yes" ]; then
	Platform="Qt/Mac"
    elif [ "$PLATFORM_X11" = "yes" ]; then
	Platform="Qt/X11"
    else
	echo >&2
	echo "Internal error." >&2
	echo >&2
	exit 2
    fi
    echo
    echo "This is the $Platform $Desc Edition."
    echo
    while true; do
	echo
	echo "Type '?' to view the $Platform License."
	echo "Type 'yes' to accept this license offer."
	echo "Type 'no' to decline this license offer."
	echo
	if echo '\c' | grep '\c' >/dev/null; then
	    echo -n "Do you accept the terms of the $Platform License? "
	else
	    echo "Do you accept the terms of the $Platform License? \c"
	fi
	read acceptance
	echo
	if [ "$acceptance" = "yes" ]; then
	    break
	elif [ "$acceptance" = "no" ]; then
	    echo "You are not licensed to use this software."
	    echo
	    exit 0
	else [ "$acceptance" = "?" ]
	    more $relpath/LICENSE
	fi
    done
fi

# 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/qmake" ];
    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 qconfig.h and qmodules.h
rm -f $outpath/include/qmake/qconfig.h
rm -f $outpath/include/qmake/qmodules.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_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 qmodules.h
#-------------------------------------------------------------------------------

rm -f $outpath/include/qmodules.h.new
cat >$outpath/include/qmodules.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 QT_MODULE_$M" >>$outpath/include/qmodules.h.new
    fi
done

# avoid unecessary rebuilds by copying only if qmodules.h has changed
if cmp -s $outpath/include/qmodules.h $outpath/include/qmodules.h.new; then
    rm -f $outpath/include/qmodules.h.new
else
    [ -f $outpath/include/qmodules.h ] && chmod +w $outpath/include/qmodules.h
    mv -f $outpath/include/qmodules.h.new $outpath/include/qmodules.h
    chmod -w $outpath/include/qmodules.h
fi

#-------------------------------------------------------------------------------
# generate QT_BUILD_KEY
#-------------------------------------------------------------------------------

# some compilers generate binary incompatible code between different versions,
# so we need to generate a build key that is different between these compilers
case "$COMPILER" in
g++*)
    # GNU C++
    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 QT_BUILD_KEY generation)
if [ -f .options ]; then
    for opt in `sort -f .options | uniq`; do
	BUILD_OPTIONS="$BUILD_OPTIONS $opt"
    done
fi
rm -f .options

BUILD_OPTIONS="$BUILD_CONFIG $BUILD_OPTIONS"
QT_BUILD_KEY="$CFG_USER_BUILD_KEY $UNAME_MACHINE $UNAME_SYSTEM $COMPILER $BUILD_OPTIONS"
# strip out leading/trailing/extra whitespace
QT_BUILD_KEY=`echo $QT_BUILD_KEY | sed -e "s,  *, ,g" -e "s,^  *,," -e "s,  *$,,"`

#-------------------------------------------------------------------------------
# part of configuration information goes into qconfig.h
#-------------------------------------------------------------------------------

case "$CFG_QCONFIG" in
full)
    echo "/* Everything */" >$outpath/include/qconfig.h.new
    ;;
*)
    QCONFIGFILE=qconfig-$CFG_QCONFIG.h
    echo "/* Copied from $QCONFIGFILE */" >$outpath/include/qconfig.h.new
    cat $relpath/src/tools/$QCONFIGFILE >>$outpath/include/qconfig.h.new
    ;;
esac
cat >> $outpath/include/qconfig.h.new <<EOF

/* License information */
#define QT_PRODUCT_LICENSEE "$Licensee"
#define QT_PRODUCT_LICENSE  "$Products"

/* Build key */
#define QT_BUILD_KEY "$QT_BUILD_KEY"

/* Machine byte-order */
#define Q_BIG_ENDIAN 4321
#define Q_LITTLE_ENDIAN 1234
EOF
if [ "$CFG_ENDIAN" = "auto" ]; then
cat >> $outpath/include/qconfig.h.new << EOF
#if defined(__BIG_ENDIAN__)
# define Q_BYTE_ORDER Q_BIG_ENDIAN
#elif defined(__LITTLE_ENDIAN__)
# define Q_BYTE_ORDER Q_LITTLE_ENDIAN
#else
# message "Unable to determine byte order!"
#endif
EOF
else
echo "#define Q_BYTE_ORDER $CFG_ENDIAN" >> $outpath/include/qconfig.h.new
fi

cat >> $outpath/include/qconfig.h.new << EOF
/* Compile time features */
EOF
[ '!' -z "$LicenseKey" ] && echo "#define QT_PRODUCT_LICENSEKEY \"$LicenseKey\"" >>$outpath/include/qconfig.h.new

if [ "$CFG_LARGEFILE" = "yes" ]; then
    echo "#define QT_LARGEFILE_SUPPORT 64" >>$outpath/include/qconfig.h.new
    if [ "$CFG_NEWABI" = "yes" ]; then
	echo "#define QT_ABI_QT4 1" >>$outpath/include/qconfig.h.new
    fi
fi

$unixtests/ptrsize.test $XQMAKESPEC $OPT_VERBOSE $relpath $outpath
echo "#define QT_POINTER_SIZE $?" >>$outpath/include/qconfig.h.new

if [ ! -z "$QT_MAC_VERSION" ]; then
    echo "#define QT_MACOSX_VERSION  ${QT_MAC_VERSION}  /*from config.tests*/" >>$outpath/include/qconfig.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/qconfig.h.new << EOF
#ifndef $cfg
# define $cfg
#endif

EOF
    done
fi

# avoid unecessary rebuilds by copying only if qconfig.h has changed
if cmp -s $outpath/include/qconfig.h $outpath/include/qconfig.h.new; then
    rm -f $outpath/include/qconfig.h.new
else
    [ -f $outpath/include/qconfig.h ] && chmod +w $outpath/include/qconfig.h
    mv $outpath/include/qconfig.h.new $outpath/include/qconfig.h
    chmod -w $outpath/include/qconfig.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
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/qmake "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/qmake $QMAKE_SWITCHES $QMAKE_SPEC_ARGS -o $OUTDIR $a
	cd $OUTDIR
	\$(MAKE) \$@

FORCE:

EOF
	else
	    EXEC="$outpath/bin/qmake $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