#!/bin/sh

#############################################################################

##

## Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

## All rights reserved.

## Contact: Nokia Corporation (qt-info@nokia.com)

##

## This file is the build configuration utility of the Qt Toolkit.

##

## $QT_BEGIN_LICENSE:LGPL$

## No Commercial Usage

## This file contains pre-release code and may not be distributed.

## You may use this file in accordance with the terms and conditions

## contained in the Technology Preview License Agreement accompanying

## this package.

##

## GNU Lesser General Public License Usage

## Alternatively, this file may be used under the terms of the GNU Lesser

## General Public License version 2.1 as published by the Free Software

## Foundation and appearing in the file LICENSE.LGPL included in the

## packaging of this file.  Please review the following information to

## ensure the GNU Lesser General Public License version 2.1 requirements

## will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

##

## In addition, as a special exception, Nokia gives you certain additional

## rights.  These rights are described in the Nokia Qt LGPL Exception

## version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

##

## If you have questions regarding the use of this file, please contact

## Nokia at qt-info@nokia.com.

##

##

##

##

##

##

##

##

## $QT_END_LICENSE$

##

#############################################################################

#-------------------------------------------------------------------------------

# script initialization

#-------------------------------------------------------------------------------

# the name of this script

relconf=`basename $0`

# the directory of this script is the "source tree"

relpath=`dirname $0`

relpath=`(cd "$relpath"; /bin/pwd)`

# the current directory is the "build tree" or "object tree"

outpath=`/bin/pwd`

#license file location

LICENSE_FILE="$QT_LICENSE_FILE"

[ -z "$LICENSE_FILE" ] && LICENSE_FILE="$HOME/.qt-license"

if [ -f "$LICENSE_FILE" ]; then

    tr -d '\r' <"$LICENSE_FILE" >"${LICENSE_FILE}.tmp"

    diff "${LICENSE_FILE}.tmp" "${LICENSE_FILE}" >/dev/null 2>&1 || LICENSE_FILE="${LICENSE_FILE}.tmp"

fi

# later cache the command line in config.status

OPT_CMDLINE=`echo $@ | sed "s,-v ,,g; s,-v$,,g"`

# initialize global variables

QMAKE_SWITCHES=

QMAKE_VARS=

QMAKE_CONFIG=

QTCONFIG_CONFIG=

QT_CONFIG=

SUPPORTED=

QMAKE_VARS_FILE=.qmake.vars

:> "$QMAKE_VARS_FILE"

#-------------------------------------------------------------------------------

# utility functions

#-------------------------------------------------------------------------------

shellEscape()

{

    echo "$@" | sed 's/ /\ /g'

}

# Adds a new qmake variable to the cache

# Usage: QMakeVar mode varname contents

#   where mode is one of: set, add, del

QMakeVar()

{

    case "$1" in

	set)

	    eq="="

	    ;;

	add)

	    eq="+="

	    ;;

	del)

	    eq="-="

	    ;;

	*)

	    echo >&2 "BUG: wrong command to QMakeVar: $1"

	    ;;

    esac

    echo "$2" "$eq" "$3" >> "$QMAKE_VARS_FILE"

}

# Helper function for getQMakeConf. It parses include statements in

# qmake.conf and prints out the expanded file

getQMakeConf1()

{

    while read line; do case "$line" in

        include*)

	    inc_file=`echo "$line" | sed -n -e "/^include.*(.*)/s/include.*(\(.*\)).*$/\1/p"`

	    current_dir=`dirname "$1"`

	    conf_file="$current_dir/$inc_file"

                echo "WARNING: Unable to find file $conf_file" >&2

                continue

            fi

            getQMakeConf1 "$conf_file"

        ;;

        *)

            echo "$line"

        ;;

    esac; done < "$1"

}

# relies on $QMAKESPEC being set correctly. parses include statements in

# qmake.conf and prints out the expanded file

getQMakeConf()

{

    tmpSPEC="$QMAKESPEC"

    if [ -n "$1" ]; then

        tmpSPEC="$1"

    fi

    getQMakeConf1 "$tmpSPEC/qmake.conf"

}

# relies on $TEST_COMPILER being set correctly

compilerSupportsFlag()

{

    cat >conftest.cpp <<EOF

int main() { return 0; }

EOF

    "$TEST_COMPILER" "$@" -o conftest.o conftest.cpp

    ret=$?

    rm -f conftest.cpp conftest.o

    return $ret

}

# relies on $TEST_COMPILER being set correctly

linkerSupportsFlag()

{

    lflags=-Wl

    for flag

    do

	safe_flag=`shellEscape "$flag"`

	lflags=$lflags,$safe_flag

    done

    compilerSupportsFlag "$lflags" >/dev/null 2>&1

}

#-------------------------------------------------------------------------------

# operating system detection

#-------------------------------------------------------------------------------

# need that throughout the script

UNAME_MACHINE=`(uname -m) 2>/dev/null` || UNAME_MACHINE=unknown

UNAME_RELEASE=`(uname -r) 2>/dev/null` || UNAME_RELEASE=unknown

UNAME_SYSTEM=`(uname -s) 2>/dev/null`  || UNAME_SYSTEM=unknown

UNAME_VERSION=`(uname -v) 2>/dev/null` || UNAME_VERSION=unknown

#-------------------------------------------------------------------------------

# window system detection

#-------------------------------------------------------------------------------

PLATFORM_X11=no

PLATFORM_MAC=no

PLATFORM_QWS=no

if [ -f "$relpath"/src/gui/kernel/qapplication_mac.mm ] && [ -d /System/Library/Frameworks/Carbon.framework ]; then

    # Qt/Mac

    # ~ the Carbon SDK exists

    # ~ src/gui/base/qapplication_mac.cpp is present

    # ~ this is the internal edition and Qt/Mac sources exist

    PLATFORM_MAC=maybe

elif [ -f "$relpath"/src/gui/kernel/qapplication_qws.cpp ]; then

    # Qt Embedded

    # ~ src/gui/base/qapplication_qws.cpp is present

    # ~ this is the free or commercial edition

    # ~ this is the internal edition and Qt Embedded is explicitly enabled

    if [ -f "$relpath"/src/gui/kernel/qapplication_mac.mm ]; then

        # This is a depot build, or an all-platforms package

        PLATFORM_QWS=maybe

    else

        # This must be the embedded package, since the Qt/Mac source files are not present

	PLATFORM_QWS=yes

    fi

fi

#-----------------------------------------------------------------------------

# Qt version detection

#-----------------------------------------------------------------------------

QT_VERSION=`grep '^# *define *QT_VERSION_STR' "$relpath"/src/corelib/global/qglobal.h`

QT_MAJOR_VERSION=

QT_MINOR_VERSION=0

QT_PATCH_VERSION=0

if [ -n "$QT_VERSION" ]; then

   QT_VERSION=`echo $QT_VERSION | sed 's,^# *define *QT_VERSION_STR *"*\([^ ]*\)"$,\1,'`

   MAJOR=`echo $QT_VERSION | sed 's,^\([0-9]*\)\.\([0-9]*\)\.\([0-9]*\).*,\1,'`

   if [ -n "$MAJOR" ]; then

     MINOR=`echo $QT_VERSION | sed 's,^\([0-9]*\)\.\([0-9]*\)\.\([0-9]*\).*,\2,'`

      PATCH=`echo $QT_VERSION | sed 's,^\([0-9]*\)\.\([0-9]*\)\.\([0-9]*\).*,\3,'`

      QT_MAJOR_VERSION="$MAJOR"

      [ -z "$MINOR" ] || QT_MINOR_VERSION="$MINOR"

      [ -z "$PATCH" ] || QT_PATCH_VERSION="$PATCH"

   fi

fi

if [ -z "$QT_MAJOR_VERSION" ]; then

   echo "Cannot process version from qglobal.h: $QT_VERSION"

   echo "Cannot proceed."

   exit 1

fi

QT_PACKAGEDATE=`grep '^# *define *QT_PACKAGEDATE_STR' "$relpath"/src/corelib/global/qglobal.h | sed -e 's,^# *define *QT_PACKAGEDATE_STR *"\([^ ]*\)"$,\1,' -e s,-,,g`

if [ -z "$QT_PACKAGEDATE" ]; then

   echo "Unable to determine package date from qglobal.h: '$QT_PACKAGEDATE'"

   echo "Cannot proceed"

   exit 1

fi

#-------------------------------------------------------------------------------

# check the license

#-------------------------------------------------------------------------------

COMMERCIAL_USER=ask

CFG_DEV=no

CFG_NOKIA=no

CFG_EMBEDDED=no

CFG_RTOS_ENABLED=yes

EditionString=Commercial

earlyArgParse()

{

    # parse the arguments, setting things to "yes" or "no"

    while [ "$#" -gt 0 ]; do

        CURRENT_OPT="$1"

        UNKNOWN_ARG=no

        case "$1" in

        #Autoconf style options

        --enable-*)

            VAR=`echo $1 | sed "s,^--enable-\(.*\),\1,"`

            VAL=yes

            ;;

        --disable-*)

            VAR=`echo $1 | sed "s,^--disable-\(.*\),\1,"`

            VAL=no

            ;;

        --*=*)

            VAR=`echo $1 | sed "s,^--\(.*\)=.*,\1,"`

            VAL=`echo $1 | sed "s,^--.*=\(.*\),\1,"`

            ;;

        --no-*)

            VAR=`echo $1 | sed "s,^--no-\(.*\),\1,"`

            VAL=no

            ;;

        -embedded)

            VAR=embedded

            # this option may or may not be followed by an argument

            if [ -z "$2" ] || echo "$2" | grep '^-' >/dev/null 2>&1; then

                VAL=auto

            else

                shift;

                VAL=$1

            fi

            ;;

        -h|help|--help|-help)

            if [ "$VAL" = "yes" ]; then

                OPT_HELP="$VAL"

                COMMERCIAL_USER="no" #doesn't matter we will display the help

            else

                UNKNOWN_OPT=yes

                COMMERCIAL_USER="no" #doesn't matter we will display the help

            fi

            ;;

        --*)

            VAR=`echo $1 | sed "s,^--\(.*\),\1,"`

            VAL=yes

            ;;

        -*)

            VAR=`echo $1 | sed "s,^-\(.*\),\1,"`

            VAL="unknown"

            ;;

        *)

            UNKNOWN_ARG=yes

            ;;

        esac

        if [ "$UNKNOWN_ARG" = "yes" ]; then

            shift

            continue

        fi

        shift

        UNKNOWN_OPT=no

        case "$VAR" in

        embedded)

            CFG_EMBEDDED="$VAL"

            if [ "$PLATFORM_QWS" != "no" ]; then

                if [ "$PLATFORM_QWS" = "maybe" ]; then

                    PLATFORM_X11=no

                    PLATFORM_MAC=no

                    PLATFORM_QWS=yes

                fi

            else

                echo "No license exists to enable Qt for Embedded Linux. Disabling."

                CFG_EMBEDDED=no

            fi

            ;;

        developer-build)

            CFG_DEV="yes"

            ;;

        nokia-developer)

            CFG_DEV="yes"

            CFG_NOKIA="yes"

            COMMERCIAL_USER="no"

            ;;

        commercial)

            COMMERCIAL_USER="yes"

            ;;

        opensource)

            COMMERCIAL_USER="no"

            ;;

        *)

            UNKNOWN_OPT=yes

            ;;

        esac

    done

}

earlyArgParse "$@"

if [ "$COMMERCIAL_USER" = "ask" ]; then

    while true; do

        echo "Which edition of Qt do you want to use ?"

        echo

        echo "Type 'c' if you want to use the Commercial Edition."

        echo "Type 'o' if you want to use the Open Source Edition."

        echo

        read commercial

        echo

        if [ "$commercial" = "c" ]; then

            COMMERCIAL_USER="yes"

            break

        elif [ "$commercial" = "o" ]; then

            COMMERCIAL_USER="no"

            break

        fi

    done

fi

if [ "$CFG_NOKIA" = "yes" ]; then

    Licensee="Nokia"

    Edition="NokiaInternalBuild"

    EditionString="Nokia Internal Build"

    QT_EDITION="QT_EDITION_OPENSOURCE"

    [ "$PLATFORM_MAC" = "maybe" ] && PLATFORM_MAC=yes

elif [ -f "$relpath"/LICENSE.PREVIEW.COMMERCIAL ] && [ $COMMERCIAL_USER = "yes" ]; then

    # Commercial preview release

    [ "$PLATFORM_MAC" = "maybe" ] && PLATFORM_MAC=yes

    Licensee="Preview"

    Edition="Preview"

    QT_EDITION="QT_EDITION_DESKTOP"

    LicenseType="Technology Preview"

elif [ $COMMERCIAL_USER = "yes" ]; then

    # one of commercial editions

    [ "$PLATFORM_MAC" = "maybe" ] && PLATFORM_MAC=yes

    [ "$PLATFORM_QWS" = "maybe" ] && PLATFORM_QWS=no

    # read in the license file

    if [ -f "$LICENSE_FILE" ]; then

        . "$LICENSE_FILE" >/dev/null 2>&1

        if [ -z "$LicenseKeyExt" ]; then

            echo

            echo "You are using an old license file."

            echo

            echo "Please install the license file supplied by Nokia,"

            echo "or install the Qt Open Source Edition if you intend to"

            echo "develop free software."

            exit 1

        fi

	if [ -z "$Licensee" ]; then

	    echo

	    echo "Invalid license key. Please check the license key."

	    exit 1

	fi

    else

        if [ -z "$LicenseKeyExt" ]; then

            echo

            if echo '\c' | grep '\c' >/dev/null; then

                echo -n "Please enter your license key: "

            else

                echo "Please enter your license key: \c"

            fi

            read LicenseKeyExt

            Licensee="Unknown user"

        fi

    fi

    # Key verification

    echo "$LicenseKeyExt" | grep ".....*-....*-....*-....*-.....*-.....*-...." >/dev/null 2>&1 \

        && LicenseValid="yes" \

        || LicenseValid="no"

    if [ "$LicenseValid" != "yes" ]; then

        echo

        echo "Invalid license key. Please check the license key."

        exit 1

    fi

    ProductCode=`echo $LicenseKeyExt | cut -f 1 -d - | cut -b 1`

    PlatformCode=`echo $LicenseKeyExt | cut -f 2 -d -`

    LicenseTypeCode=`echo $LicenseKeyExt | cut -f 3 -d -`

    LicenseFeatureCode=`echo $LicenseKeyExt | cut -f 4 -d - | cut -b 1`

    # determine which edition we are licensed to use

    case "$LicenseTypeCode" in

    F4M)

        LicenseType="Commercial"

        case $ProductCode in

        F)

            Edition="Universal"

            QT_EDITION="QT_EDITION_UNIVERSAL"

            ;;

        B)

            Edition="FullFramework"

            EditionString="Full Framework"

            QT_EDITION="QT_EDITION_DESKTOP"

            ;;

        L)

            Edition="GUIFramework"

            EditionString="GUI Framework"

            QT_EDITION="QT_EDITION_DESKTOPLIGHT"

            ;;

        esac

        ;;

    Z4M|R4M|Q4M)

        LicenseType="Evaluation"

        QMakeVar add DEFINES QT_EVAL

        case $ProductCode in

         B)

            Edition="Evaluation"

            QT_EDITION="QT_EDITION_EVALUATION"

            ;;

        esac

        ;;

    esac

    if [ -z "$LicenseType" -o -z "$Edition" -o -z "$QT_EDITION" ]; then

        echo

        echo "Invalid license key. Please check the license key."

        exit 1

    fi

    # verify that we are licensed to use Qt on this platform

    LICENSE_EXTENSION=

    case "$PlatformCode" in

	*L)

	    CFG_RTOS_ENABLED=yes

	    PlatformCode=`echo "$PlatformCode" | sed 'h;y/8NPQRTZ/UCWX9M7/;x;G;s/\(.\)....\(.\)./\1\2/'`

	    ;;

	*)

	    CFG_RTOS_ENABLED=no

	    PlatformCode=`echo "$PlatformCode" | sed 's/.$//'`

	    ;;

    esac

    case "$PlatformCode,$PLATFORM_MAC,$PLATFORM_QWS" in

        X9,* | XC,* | XU,* | XW,* | XM,*)

            # Qt All-OS

            LICENSE_EXTENSION="-ALLOS"

            ;;

        8M,* | KM,* | S9,* | SC,* | SU,* | SW,* | X9,* | XC,* | XU,* | XW,*)

            # Qt for Embedded Linux

            LICENSE_EXTENSION="-EMBEDDED"

            ;;

        6M,*,no | N7,*,no | N9,*,no | NX,*,no)

            # Embedded no-deploy

            LICENSE_EXTENSION="-EMBEDDED"

            ;;

        FM,*,no | LM,yes,* | ZM,no,no)

            # Desktop

            LICENSE_EXTENSION="-DESKTOP"

            ;;

        *)

            Platform=Linux/X11

            [ "$PLATFORM_MAC" = "yes" ] && Platform='Mac OS X'

            [ "$PLATFORM_QWS" = "yes" ] && Platform='Embedded Linux'

            echo

            echo "You are not licensed for the $Platform platform."

            echo

            echo "Please contact qt-info@nokia.com to upgrade your license to"

            echo "include the $Platform platform, or install the Qt Open Source Edition"

            echo "if you intend to develop free software."

            exit 1

            ;;

    esac

    if test -r "$relpath/.LICENSE"; then

	# Generic, non-final license

	LICENSE_EXTENSION=""

	line=`sed 'y/a-z/A-Z/;q' "$relpath"/.LICENSE`

	case "$line" in

	    *BETA*)

		Edition=Beta

		;;

	    *TECHNOLOGY?PREVIEW*)

		Edition=Preview

		;;

	    *EVALUATION*)

		Edition=Evaluation

		;;

	    *)

		echo >&2 "Invalid license files; cannot continue"