#!/bin/bash

#

# Script for setting up the Desktop Build Environment on Solaris

#

# CDDL HEADER START

#

# The contents of this file are subject to the terms of the

# Common Development and Distribution License, Version 1.0 only

# (the "License").  You may not use this file except in compliance

# with the License.

#

# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

# or http://www.opensolaris.org/os/licensing.

# See the License for the specific language governing permissions

# and limitations under the License.

#

# When distributing Covered Code, include this CDDL HEADER in each

# file and include the License file at usr/src/OPENSOLARIS.LICENSE.

# If applicable, add the following below this CDDL HEADER, with the

# fields enclosed by brackets "[]" replaced with your own identifying

# information: Portions Copyright [yyyy] [name of copyright owner]

#

# CDDL HEADER END

#

#

# Copyright 2008 Sun Microsystems, Inc.  All rights reserved.

# Use is subject to license terms.

#

IFS=' 	

'

# this is listed separately because we are using the spec file

# included in the pkgbuild tarball

# Modules needed for building GNOME:

GNOME_MODULES="ant m4 autoconf automake libtool bison coreutils diff flex gettext make subversion"

# Modules needed for building KDE:

KDE_MODULES="ant m4 autoconf automake libtool bison coreutils diff flex gettext subversion gnuawk gnused cmake make yasm"

# Not needed for either GNOME or KDE, but useful to have:

OPT_MODULES="rsync cvs"

# SFE has the same deps as GNOME

SFE_MODULES=$GNOME_MODULES

install_kde=no

install_gnome=no

install_sfe=no

install_opt=no

interactive_install=yes

quiet_install=no

default_compiler=

orig_CC="${CC}"

# Obsolete packages to be pkgrm'd.  Mostly renamed packages.

OLD_PKGS="JDSautomake JDSautoconf JDSlibtool JDSm4 JDSgettext JDSfileutils 

          JDSmake JDSpatch CBEpatch JDSflex JDScvs SUNWpkgbuild CBEfileutils"

# default log file.  Changed to /tmp/desktop-cbe-install* if the user

# installing is not root

LOGFILE=/tmp/desktop-cbe-install-`date +%Y-%m-%d-%H:%M`.log

# packages required for building things.  cbe-install will check if they

# are installed and install them if not.

# Solaris SVr4 packages:

CBE_SVR4_DEPENDENCIES="SUNWarc SUNWgpch SUNWhea SUNWsfwhea SUNWwgetr

                       SUNWwgetu SUNWgtar SUNWxcu4 SUNWsprot SUNWxwinc

                       SUNWxorg-headers SUNWbtool SUNWlibmr SUNWlibm"

# OpenSolaris pkg(5) packages:

CBE_PKG_DEPENDENCIES="SUNWgpch SUNWhea SUNWsfwhea SUNWwget SUNWgtar

                       SUNWxcu4 SUNWsprot SUNWxwinc SUNWxorg-headers

                       SUNWbtool SUNWlibm"

# alternatives (SUNW version of tools preferred to CBE version)

# by detault install alternatives when available

install_alt=yes

# by default, install alternatives without asking

ask_alt=no

ALT_make=SUNWgmake

ALT_m4=SUNWgm4

ALT_autoconf=SUNWaconf

ALT_automake="SUNWgnu-automake-110 SUNWgnu-automake-19"

ALT_libtool=SUNWlibtool

ALT_bison=SUNWbison

ALT_coreutils=SUNWgnu-coreutils

ALT_diff=SUNWgnu-diffutils

ALT_flex=SUNWflexlex

ALT_gettext=SUNWgnu-gettext

ALT_subversion=SUNWsvn

ALT_gnused=SUNWgsed

ALT_gnuawk=SUNWgawk

# Do not use SUNWcmake, because it does not contain fix for Sun Studio optimalization. --luc

#ALT_cmake=SUNWcmake

# In SXCE build107 SUNWant = ant 1.7.1

#ALT_ant=SUNWant

# default cbe install location

cbe_prefix=${CBE_PREFIX:-/opt/dtbld}

# this should be set to a reasonable value in install_pkgbuild()

pkgbuild_topdir=/fix/me

# default value for the "who is the build user" question

logname=${LOGNAME:-`logname`}

if [ -x /usr/xpg4/bin/id ]; then

    uid=`/usr/xpg4/bin/id -u`

    username=`/usr/xpg4/bin/id -un`

else

    uid=`/bin/id | cut -f2 -d= | cut -f1 -d'('`

    username=`/bin/id |cut -f2 -d'(' | cut -f1 -d')'`

fi

export HOME="$(eval cd ~$username; pwd)"

always_uninstall_existing=

always_skip_existing=

# write a message to the log file

# not visible to the user

log () {

    for msg in "${@}"; do

	echo "`date`: $msg" >> $LOGFILE

    done

}

# print a message to the user and also write it to the log file

msg () {

    for msg in "${@}"; do

	if [ $quiet_install = no ]; then

	    echo $msg

	fi

	echo "`date`: $msg" >> $LOGFILE

    done

}

# print a message to the user and also write it to the log file

msg_err () {

    for msg in "${@}"; do

	if [ $quiet_install = no ]; then

	    echo ERROR: $msg 1>&2

	fi

	echo "`date`: ERROR: $msg" >> $LOGFILE

    done

}

# clean up if installation is aborted

tempdirs=

remove_tempdirs () {

    IFS=:

    for tdir in $tempdirs; do

	case "$tdir" in

	    /tmp/* )

                cd /tmp

		rm -rf "$tdir"

		;;

	esac

    done

}

trap remove_tempdirs QUIT EXIT

# alternate root directory

rootdir=/

process_cl () {

    while [ $# != 0 ]; do

	case "$1" in

	    -R )

		shift

		if [ $# == 0 ]; then

		    echo "Option -R requires an argument." 1>&2

		    exit 1

		fi

		rootdir=$1

		case "$rootdir" in

		    /* )

			;;

		    * )

			echo "The argument to -R must be an absolute path name" 1>&2

			exit 1

		esac

		;;

	    -h|--help)

		echo "Usage: $0 [options]"

		echo "options:"

		echo "   -h, --help        print this usage info"

		echo "   -R rootdir        install CBE packages in alternate root directory rootdir"

		echo "   -k, --kde         install the packages needed for building KDE"

		echo "   -g, --gnome       install the packages needed for building GNOME"

		echo "   -s, --sfe         install the packages needed for building GNOME"

		echo "   -o, --optional    install the optional packages"

		echo "   -n                non-interactive installation -- assumes the default"

		echo "   -q, --quiet       quiet install, messages are printed in the log only"

		echo "                     answers to all questions"

		echo "   -p dir, --prefix dir"

                echo "                     install the Desktop CBE to dir"

		echo "   --ask-alt         ask for confirmation before installing alternative"

                echo "                     tools ([Open]Solaris tools instead of CBE tools)"

		echo "   --no-alt          do not install alternatives, only CBE tools"

		exit 0

		;;

	    --ask-alt)

		ask_alt=yes

		;;

	    -c|--compiler)

		shift

		if [ $# == 0 ]; then

		    echo "Option -R requires an argument." 1>&2

		    exit 1

		fi

		default_compiler=$1

		test -x $default_compiler || {

		    echo "Compiler $default_compiler not found" 1>&2

		    exit 1

		}

		;;

	    -q|--quiet)

		quiet_install=yes

		;;

	    --no-alt)

		install_alt=no

		;;

	    -k|--kde)

		install_kde=yes

		;;

	    -g|--gnome)

		install_gnome=yes

		;;

	    -s|--sfe)

		install_gnome=yes

		;;

	    -o|--optional)

		install_opt=yes

		;;

	    -n)

		interactive_install=no

		;;

	    -p|--prefix)

                shift

		test $# = 0 && {

		    echo "ERROR: argument required after -p or --prefix option" 1>&2

		}

		cbe_prefix="$1"

		test ${cbe_prefix:0:1} = / || {

		    echo "ERROR: the prefix must be an absolute path" 1>&2

		}

		;;

	    *)

		echo "Unknown option: $1" 1>&2

		exit 1

		;;

	esac

	shift

    done

    if [ $interactive_install = yes ]; then

	quiet_install=no

    fi

}

# check the type and name of the compiler

# set CXX to match CC

identify_compiler () {

    id_CC=$1

    id_CC_name=unknown

    id_CC_release=

    id_CC_version=

    id_CC_rev=

    id_CC_label=unknown

    id_CC_dir=$(dirname $id_CC)

    # check if it's gcc

    cc_version=$($id_CC --version 2>&1)

    echo "$cc_version" | grep 'gcc (GCC)' > /dev/null && {

	id_CC_name='GNU gcc'

	id_CC_version=$(echo "$cc_version" | grep 'gcc (GCC)' | cut -f3 -d' ')

	id_CC_release=$(echo $id_CC_version | cut -f1 -d.)

	id_CC_label=gcc${id_CC_release}

	CXX="$id_CC_dir/g++"

	if [ ! -x "$CXX" ]; then

	    msg "WARNING: $CXX not found"

	fi

	log "$id_CC is $id_CC_name release $id_CC_release"

	return

    }

    cc_version=$($id_CC -V 2>&1)

    echo "$cc_version" | grep '^cc: Sun ' > /dev/null && {

	id_CC_name='Sun Studio'

	id_CC_version=$(echo "$cc_version" | grep '^cc: Sun ' | sed -e 's/^cc: Sun.* C \([0-9][0-9.]*\) .*/\1/')

	id_CC_rev=$(echo "$cc_version" | grep '^cc: Sun ' | sed -e 's/^cc: Sun.* C [0-9][0-9.]* \(.\)*/\1/')

	id_CC_rev=$(echo "$id_CC_rev" | grep '^cc: Sun ' | sed -e 's/SunOS_[^ ]* //')

	if [ "x$id_CC_version" = x5.7 ]; then

	    id_CC_label='ss10'

	    id_CC_release='Vulcan'

	    id_CC_name='Sun Studio 10'

	elif [ "x$id_CC_version" = x5.8 ]; then

	    id_CC_label='ss11'

	    id_CC_release='Venus'

	    id_CC_name='Sun Studio 11'

	elif [ "x$id_CC_version" = x5.9 ]; then

	    id_CC_label='ss12'

	    id_CC_release='Mars'	    

	    id_CC_name='Sun Studio 12'

	elif [ "x$id_CC_version" = x5.10 ]; then

	    id_CC_label='sexp'

	    id_CC_release='Ceres'

	    id_CC_name='Sun Studio Express'

	else

	    id_CC_label="Studio_$id_CC_version"

	    id_CC_release="$id_CC_version"

	fi

	CXX="$id_CC_dir/CC"

	if [ ! -x "$CXX" ]; then

	    msg "WARNING: $CXX not found"

	fi

	log "$id_CC is $id_CC_name release $id_CC_release"

	return

    }

    msg "WARNING: could not identify $id_CC = $cc_version"

}

# create a build environent config file for the given build compiler

make_env () {

    env_compiler=$1

    envdir=$tempdir/env

    logrun mkdir -p $envdir

    identify_compiler $env_compiler

    if [ "$id_CC_name" = unknown ]; then

	log "Compiler $1 is unknown, ignoring"

	return 1

    fi

    # identify_compiler sets CXX to match CC

    # also id_CC_name, id_CC_label, id_CC_version, id_CC_release, id_CC_rev

    env_file="$envdir/$id_CC_label"

    env_nr=1

    while test -f $env_file; do

	env_file="$envdir/${id_CC_label}.${env_nr}"

	env_nr=$(($env_nr + 1))

    done

    log "creating env file for compiler $1 ($id_CC_name)"

    echo '# Build environment config file for the Desktop CBE' > "$env_file"

    echo "CC_name='$id_CC_name'"       >> "$env_file"

    echo "CC_version='$id_CC_version'" >> "$env_file"

    echo "CC_release='$id_CC_release'" >> "$env_file"

    echo "CC_rev='$id_CC_rev'"         >> "$env_file"

    echo "cc_dir='$id_CC_dir'"         >> "$env_file"

    echo "CC='$env_compiler'"          >> "$env_file"

    echo "CXX='$CXX'"                  >> "$env_file"

    return 0

}

# look for compilers in known locations

find_compilers () {

    compiler_found=no

    # FIXME: if CC = gcc, set CFLAGS to -std=c99

    msg "Locating compilers..."

    arch=$(uname -p)

    if [ "x$orig_CC" != x ]; then

	if [ -x $orig_CC ]; then

	    echo " $known_compilers " | grep " $orig_CC " > /dev/null || \

		known_compilers="$orig_CC $known_compilers"

	fi

    fi

    for compiler in $known_compilers; do

	if [ -x $compiler -a ! -d $compiler ]; then

	    make_env $compiler

	    compiler_found=yes

	fi

    done

}

# download pkgbuild from sourceforge using wget

download_pkgbuild () {

    mkdir -p $tardir

    /usr/sfw/bin/wget -nd -nH --tries=1 -T 60 -O $tardir/pkgbuild-${PKGBUILD_VERSION}.tar.bz2 http://internode.dl.sourceforge.net/sourceforge/pkgbuild/pkgbuild-${PKGBUILD_VERSION}.tar.bz2 || {

	msg "Failed to download pkgbuild, cannot continue."

	exit 1

    }

}

ask_compiler () {

    ask 'Enter the path to the C compiler' ans_compiler

    if [ ! -x $ans_compiler ]; then

	msg "Invalid answer: $ans_compiler is not an executable"

	return 1

    fi

    if [ -d $ans_compiler ]; then

	msg "Invalid answer: $ans_compiler is a directory"

	return 1

    fi

    identify_compiler "$ans_compiler"

    if [ x$ans_compiler == xunknown ]; then

	msg "Unknown compiler: $ans_compiler"

	return 1

    fi

    compiler_found=yes

    make_env "$ans_compiler"

    return 0

}

# ask the user for additional compiler locations

ask_compilers () {

    first=$1

    ans_more_compilers=yes

    while [ $ans_more_compilers = yes ]; do

	if [ "x$first" = xfirst ]; then

	    msg "You need a C compiler in order to use the Desktop CBE"

	    ask_compiler && first=no

	else

	    ask_yes_no 'Would you like to configure more compilers for use with the Desktop CBE?' ans_more_compilers no

	    if [ $ans_more_compilers = yes ]; then

		ask_compiler

	    fi

	fi

    done

}

# install gcc and/or Sun Studio

install_compilers_pkg () {

    # ask if gcc should be installed

    ask_yes_no "Would you like to install gcc (GNU C compiler)?" \

	ans_install_gcc yes

    test "$ans_install_gcc" = yes && pkg_try_install SUNWgcc

    # ask if sun studio express should be installed

    ask_yes_no "Would you like to install Sun Studio Express (cc 5.10)?" \

	ans_install_ssexp yes

    test "$ans_install_ssexp" = yes && pkg_try_install sunstudioexpress

}

check_compilers_kde () {

    :

}

# print the details of a compiler specified by its env config file

display_compiler () {

    . $1

    msg "$2 - $CC_name $CC_version ($CC_release) in $cc_dir"

}

# select the default compiler configuration

select_default_compiler () {

    if [ "x$default_compiler" != x ]; then

	grep "^CC='$default_compiler'\$" $envdir/* > /dev/null || {

	    make_env $default_compiler && compiler_found=yes

	}

    fi

    found_default_compiler=

    found_CC=

    if [ $compiler_found = yes ]; then

	msg ""

	msg "The following compilers were found on your system:"

	i=1

	for env in $envdir/*; do

	    display_compiler $env $i

	    test "x$default_compiler" != x && \

		grep "^CC='$default_compiler'\$" $env > /dev/null && \

		found_default_compiler=$i

	    test "x$CC" != x && \

		grep "^CC='$orig_CC'\$" $env > /dev/null && \

		found_CC=$i

	    eval env_$i="$env"

	    i=$((i + 1))

	done

	i=$(($i - 1))

	if [ "x$1" != xdont_ask -a "x$found_default_compiler" = x ]; then

	    ask_compilers

	    # don't ask again if the user whats to configure more compilers

	    select_default_compiler dont_ask

	    return

	fi