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

PKGBUILD_VERSION=1.3.0

# 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

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

OLD_PKGS="JDSautomake JDSautoconf JDSlibtool JDSm4 JDSgettext JDSfileutils 

          JDSmake JDSpatch CBEpatch JDSflex JDScvs SUNWpkgbuild"

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

# installing is not root

LOGFILE=/var/sadm/install/logs/desktop-cbe.install.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

# not yet available

#ALT_gettext=SUNWgnu-gettext

ALT_subversion=SUNWsvn

# default cbe install location

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

	echo $msg

	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

	echo ERROR: $msg 1>&2

	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."

		    exit 1

		fi

		rootdir=$1

		case "$rootdir" in

		    /* )

			;;

		    * )

			echo "The argument to -R must be an absolute path name"

			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 "   --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

		;;

	    --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

		;;

	    *)

		echo "Unknown option: $1"

		exit 1

		;;

	esac

	shift

    done

}

# 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

	return

    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

    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"

}

# 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)

    known_compilers="/sgnome/onnv-tools/$arch/SS12/bin/cc /sgnome/onnv-tools/$arch/SS11/bin/cc /ws/onnv-tools/SUNWspro/SS12/bin/cc /ws/onnv-tools/SUNWspro/SS11/bin/cc /opt/SUNWspro/bin/cc /usr/bin/cc /opt/SunStudioExpress/bin/cc /usr/bin/gcc /usr/sfw/bin/gcc /usr/gnu/bin/gcc"

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

	if [ ! -x $CC ]; then

	    unset CC

	else

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

		known_compilers="$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

}

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

display_compiler () {

    . $1

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

}

# select the default compiler configuration

select_default_compiler () {

    if [ $compiler_found = yes ]; then

	echo

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

	i=1

	for env in $envdir/*; do

	    display_compiler $env $i

	    eval env_$i="$env"

	    i=$((i + 1))

	done

	i=$(($i - 1))

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

	    ask_compilers

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

	    select_default_compiler dont_ask

	    return

	fi

    else

	echo "No compilers were found on your system."

	if [ $PKG_SYSTEM = pkg ]; then

	    ask_yes_no "Would you like the to install compilers now?" \

		ans_install_compiler yes

	    if [ x$ans_install_compiler = yes ]; then

		install_compilers_pkg && {

		    find_compilers

	            # don't ask again if the user whats

		    # to configure more compilers

		    select_default_compiler dont_ask

		    return

		}

	    fi

	fi

	ask_compilers first

	select_default_compiler dont_ask

	return

    fi

    if [ $i = 1 ]; then

	# there's only one compiler no need to ask which one's the default

	ans_default_compiler=1

    else

	ans_default_compiler=9999

	while [ $ans_default_compiler -gt $i ]; do

	    ask 'Please select the default compiler' ans_default_compiler $i

	    is_number "$ans_default_compiler" || {

		echo "Please enter a number from 1 to $i"

		ans_default_compiler=9999

	    }

	done

    fi

    eval default_env="\$env_$ans_default_compiler"

    if [ ! -f $default_env ]; then

	msg "Internal error in cbe-install, please report to desktop-discuss"

    fi

    . $default_env

    export CC

    export CXX

}

# verify that the running system is suitable for the Desktop CBE

# and set up some variables

init () {

    myos=`uname -s`

    if [ "x$myos" != xSunOS ]; then

	echo "Run this script on a Solaris system."

	exit 1

    fi

    umask 0022

    the_cpu=`uname -p`

    if [ "x$the_cpu" != xsparc ]; then

	the_cpu=x86

    fi

    myos_rel=`uname -r`

    if [ "x$myos_rel" = "x5.10" -o "x$myos_rel" = "x5.10.1" -o "x$myos_rel" = "x5.11" ]; then

	:

    else

	echo "Solaris 10, Solaris Nevada or OpenSolaris required."

	exit 1

    fi

    if [ "x$myos_rel" = "x5.10" ]; then

	solaris_pkg_dir=/cdrom/cdrom0/Solaris_10/Product

    elif [ "x$myos_rel" = "x5.11" ]; then

	solaris_pkg_dir=/cdrom/cdrom0/Solaris_11/Product

    fi

    mydir=$(cd $(dirname $0); pwd);

    tardir=${mydir}/tarballs

    CBE_VERSION=`cat $mydir/CBE_VERSION`

    echo "Desktop Common Build Environment (CBE) Installer version $CBE_VERSION"

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

    if [ "x$my_id" != x0 ]; then

	prof_sw_inst=`/bin/profiles | nl -s: | grep 'Software Installation' | cut -f1 -d:`

	prof_pri_adm=`/bin/profiles | nl -s: | grep 'Primary Administrator' | cut -f1 -d:`

	prof_basic_usr=`/bin/profiles | nl -s: | grep 'Basic Solaris User' | cut -f1 -d:`

	if [ "x$prof_sw_inst" = x -a "x$prof_pri_adm" = x ]; then

	    echo 'Run this script as root or as a user with the "Software Installation"'

	    echo 'or "Primary Administrator" profile.'