#!/bin/sh
##############################################################################
#                      __                                                    #
#      ________ ___   / /  ___     Scala Tools Launch Script                 #
#     / __/ __// _ | / /  / _ |    (c) 2002-2006, LAMP/EPFL                  #
#   __\ \/ /__/ __ |/ /__/ __ |                                              #
#  /____/\___/_/ |_/____/_/ | |                                              #
#                           |/                                               #
##############################################################################

# $Id$

##############################################################################
# Error functions

# Prints a warning message on stderr.
warning() {
    echo "$0: warning:" "$@" 1>&2;
}

# Prints an error message on stderr.
error() {
    echo "$0:" "$@" 1>&2;
}

# Prints an error message on stderr and exits with a non-zero status.
abort() {
    error "$@";
    exit 1;
}

##############################################################################
# Printing functions

# Initializes the printf functions
printf_initialization() {
    case "$1" in
        many )
            printf_font_outline="printf \\033[1;39m";
            printf_font_success="printf \\033[1;32m";
            printf_font_failure="printf \\033[1;31m";
            printf_font_warning="printf \\033[1;33m";
            printf_font_default="printf \\033[0;39m";
            ;;
        some )
            printf_font_outline="printf \\033[1m";
            printf_font_success="printf \\033[0m";
            printf_font_failure="printf \\033[1m";
            printf_font_warning="printf \\033[1m";
            printf_font_default="printf \\033[0m";
            ;;
        none )
            printf_font_outline="";
            printf_font_success="";
            printf_font_failure="";
            printf_font_warning="";
            printf_font_default="";
            ;;
        * )
            abort "unknown color mode \`$1'";
            ;;
    esac;
}

# Prints formated text in outline font.
printf_outline() {
    $printf_font_outline;
    printf "$@";
    $printf_font_default;
}

##############################################################################
# File name and path list conversion functions

# Prints the OS-specific form of the specified Unix form file name.
get_os_filename() {
    [ $# = 1 ] || abort "internal error";
    case "$UNAME" in
        CYGWIN* ) cygpath --windows "$1";;
        *       ) echo "$@";;
    esac;
}

# Prints the Unix form of the specified OS-specific form file name.
get_unix_filename() {
    [ $# = 1 ] || abort "internal error";
    case "$UNAME" in
        CYGWIN* ) cygpath --unix "$1";;
        *       ) echo "$@";;
    esac;
}

# Prints the OS-specific form of the specified Unix form path list.
get_os_pathlist() {
    [ $# = 1 ] || abort "internal error";
    case "$UNAME" in
        CYGWIN* ) cygpath --window --path "$1";;
        *       ) echo "$@";;
    esac;
}

# Prints the Unix form of the specified OS-specific form path list.
get_unix_pathlist() {
    [ $# = 1 ] || abort "internal error";
    case "$UNAME" in
        CYGWIN* ) cygpath --unix --path "$1";;
        *       ) echo "$@";;
    esac;
}

##############################################################################
# Implementation of clitest

# Prints the clitest usage.
test_print_usage() {
    [ $# = 0 ] || abort "internal error";
    echo "Usage: $0 [OPTION]..."
}

# Prints the clitest help.
test_print_help() {
    [ $# = 0 ] || abort "internal error";
    test_print_usage;
    echo "";
    echo "--quick         use the 'quick' build instead of distribution";
    echo '--installed     use the installed programs on $PATH'
    echo "--debug         redirect all outputs to standard output";
    echo "--info          display information messages";
    echo "--javac         run same tests with the Sun Java compiler";
    echo "--jikes         run same tests with the IBM Java compiler";
    echo "--jredir=<dir>  specify the Sun JRE installation directory (jikes)";
    echo "--objdir=<dir>  specify where to place generated files";
    echo "--verbose       display verbose messages";
    echo "--help, -?      display this help and exit";
    echo "--version       output version information and exit";
}

# Prints the clitest version.
test_print_version() {
    [ $# = 0 ] || abort "internal error";
    echo "$SCRIPT 1.3";
}

# Adds a new file to the appropriate file list(s).
test_add_file() {
    [ $# = 1 ] || abort "internal error";
    case "$1" in
        *.scala )
            if [ ! \( -d "$1" -o -f "$1" \) ]; then
                abort "don't know what to do with '$1'";
            fi;
            dir=`dirname "$1"`;
            file=`cd $dir && pwd`/`basename $1`;
            FILES="$FILES $file";;
        * )
            if [ ! -d "$1" ]; then
                abort "don't know what to do with '$1'";
            fi;
            dir=`cd "$1" && pwd`;
            file=`find "$dir" -name "Main$SUFFIX" -a -type f -print`;
            FILES="$FILES $file";;
    esac;
}

test_run() {
    [ $# = 1 ] || abort "internal error";
    cmd="$1"; shift 1;
    [ "$DEBUG" = "debug" ] && ( printf_outline "[DEBUG]"; echo "$cmd");
    eval "$cmd";
}

test_diff() {
    [ $# = 2 ] || abort "internal error";
    check="$1"; shift 1;
    log="$1"; shift 1;
    [ "$DEBUG" = "debug" ] && return;
    sed -e "s#$TEST_DIR/##g" $log > $TMP_FILE;
    $DIFF $check $TMP_FILE > $DIFF_FILE
    if [ -n "`cat $DIFF_FILE`" ] ; then
        printf_outline "\\nDifferences between check and log files:\\n";
        file=`echo $check | sed -e "s#$PREFIX/##g"`;
        printf "$file\\n";
        cat $DIFF_FILE;
    fi
}

test_compile() {
    [ $# = 3 ] || abort "internal error";
    source="$1"; shift 1;
    check="$1"; shift 1;
    info="$1"; shift 1;
    [ -d "$OUTPUT_DIR" ] || mkdir -p $OUTPUT_DIR;
    [ -f "$LOG_FILE" ] && $RM $LOG_FILE;
    if [ "$COMPILER" = "javac" ] || [ "$COMPILER" = "jikes" ]; then
        suffix=".${COMPILER}";
        [ "$LANG" = "java5" ] && suffix=".${COMPILER}5";
        [ "$LANG" = "java6" ] && suffix=".${COMPILER}6";
    else
        suffix=".$COMPILER";
    fi;
    file=`echo $source | sed -e "s#$PREFIX/##g"`;
    if [ "$LEVEL" = "info" ] || [ "$LEVEL" = "verbose" ] ; then
        printf_outline "\\nSource file: $file\\n"
        cat $source;
    fi
    printf "\\n";

    #=`get_unix_filename "$source"`;
    printf "Compile $file ($info) with unknown option '-dd'\\n"
    test_run "env CLASSPATH= $COMPILER_COMMAND \
        -dd $OUTPUT_DIR $source 2>> $LOG_FILE 1>> $LOG_FILE";

    printf "Compile $file ($info) with no classpath information\\n"
    test_run "env CLASSPATH= $COMPILER_COMMAND \
        -d $OUTPUT_DIR $source 2>> $LOG_FILE 1>> $LOG_FILE";

    printf "Compile $file ($info) with variable CLASSPATH\\n"
    test_run "env CLASSPATH=$OUTPUT_DIR $COMPILER_COMMAND \
        -d $OUTPUT_DIR $source 2>> $LOG_FILE 1>> $LOG_FILE";

    printf "Compile $file ($info) with option -classpath\\n"
    test_run "env CLASSPATH= $COMPILER_COMMAND -classpath $OUTPUT_DIR \
        -d $OUTPUT_DIR $source 2>> $LOG_FILE 1>> $LOG_FILE";

    printf "Compile $file ($info) with current directory as default classpath\\n"
    test_run "(cd $OUTPUT_DIR &&
        env CLASSPATH= $COMPILER_COMMAND $source 2>> $LOG_FILE 1>> $LOG_FILE)";

    test_diff "$check$suffix" "$LOG_FILE";

    if [ "$LEVEL" = "verbose" ] ; then
        printf_outline "\\nTest directory:\\n";
        $TREE $TMP_DIR;
    fi
}

test_execute() {
    [ $# = 2 ] || abort "internal error";
    main="$1"; shift 1;
    check="$1"; shift 1;
    suffix=".$LANG";
    [ "$LANG" = "java6" ] && suffix=".java5";

    [ -f "$LOG_FILE" ] && $RM $LOG_FILE;
    printf "\\n";

    printf "Execute $main with unknown option '-cpp'\\n"
    test_run "env CLASSPATH= \
        $RUNTIME_COMMAND -cpp $OUTPUT_DIR $main 2 \
        2>> $LOG_FILE 1>> $LOG_FILE";

    printf "Execute $main with variable CLASSPATH\\n"
    test_run "env CLASSPATH=$OUTPUT_DIR \
        $RUNTIME_COMMAND $main 1 \
        2>> $LOG_FILE 1>> $LOG_FILE";

    printf "Execute $main with option -classpath\\n"
    test_run "env CLASSPATH= \
        $RUNTIME_COMMAND -classpath $OUTPUT_DIR $main 2 \
        2>> $LOG_FILE 1>> $LOG_FILE";

    printf "Execute $main with current directory as default classpath\\n"
    test_run "(cd $OUTPUT_DIR &&
        env CLASSPATH= $RUNTIME_COMMAND $main 3 2>> $LOG_FILE 1>> $LOG_FILE)";

    printf "Execute $main with quoted argument\\n"
    test_run "env CLASSPATH= \
        $RUNTIME_COMMAND -classpath $OUTPUT_DIR $main 4 \"a b c\" \
        2>> $LOG_FILE 1>> $LOG_FILE";

    test_diff "$check$suffix" "$LOG_FILE";
}

test_interpret() {
    [ $# = 2 ] || abort "internal error";
    main="$1"; shift 1;
    check="$1"; shift 1;
    [ "$LANG" = "scala" ] || return;
    [ -f "$LOG_FILE" ] && $RM $LOG_FILE;
    printf "\\n"

    printf "Interpret $main with unknown option '-cpp'\\n"
    test_run "(env CLASSPATH= \
        printf $main'.main(Array(\"0\"))\n:q' | $INTERPRETER_COMMAND \
        -cpp $OUTPUT_DIR 2>> $LOG_FILE 1>> $LOG_FILE)";
    printf "\\n" >> $LOG_FILE  # newline

    printf "Interpret $main with variable CLASSPATH\\n"
    test_run "(printf $main'.main(Array(\"1\"))\n:q' \
        | env CLASSPATH=$OUTPUT_DIR $INTERPRETER_COMMAND \
        2>> $LOG_FILE 1>> $LOG_FILE)";
    printf "\\n" >> $LOG_FILE  # newline

    printf "Interpret $main with option -classpath\\n"
    test_run "(env CLASSPATH= \
        printf $main'.main(Array(\"2\"))\n:q' | $INTERPRETER_COMMAND \
        -classpath $OUTPUT_DIR 2>> $LOG_FILE 1>> $LOG_FILE)";
    printf "\\n" >> $LOG_FILE  # newline

    printf "Interpret $main with current directory as default classpath\\n"
    test_run "(cd $OUTPUT_DIR &&
        printf $main'.main(Array(\"3\"))\n:q' | $INTERPRETER_COMMAND \
        2>> $LOG_FILE 1>> $LOG_FILE)";
    printf "\\n" >> $LOG_FILE # newline

    test_diff "$check.scalaint" "$LOG_FILE";
}

test_docgen() {
    [ $# = 2 ] || abort "internal error";
    source="$1"; shift 1;
    check="$1"; shift 1;
    [ -d "$OUTPUT_DIR" ] || mkdir -p $OUTPUT_DIR;
    [ -f "$LOG_FILE" ] && $RM $LOG_FILE;
    [ -d "$API_DIR" ] && $RM -r "$API_DIR/*" || mkdir -p $API_DIR; 
    suffix=".${LANG}_api";
    file=`echo $source | sed -e "s#$PREFIX/##g"`;
    if [ "$LEVEL" = "info" ] || [ "$LEVEL" = "verbose" ] ; then
        printf_outline "\\nSource file: $file\\n"
        cat $source;
    fi
    printf "\\n";

    printf "Generate documentation for $file\\n"
    test_run "env CLASSPATH= $DOCGEN_COMMAND \
        -d $API_DIR $source 2>> $LOG_FILE 1>> $LOG_FILE";

    n=`$TREE $API_DIR | wc -l`;
    $TREE $API_DIR | tail -n `echo "$n-1" | bc` > "$LOG_FILE";
    test_diff "$check$suffix" "$LOG_FILE";

    if [ "$LEVEL" = "verbose" ] ; then
        printf_outline "\\nAPI directory:\\n";
        $TREE $API_DIR;
    fi
}

##############################################################################
# Initialization

unset SCRIPT;
UNAME=`uname`;
SOURCE=$0;
SCRIPT=`basename "$SOURCE"`;
while [ -h "$SOURCE" ]; do
    SCRIPT=`basename "$SOURCE"`;
    LOOKUP=`ls -ld "$SOURCE"`;
    TARGET=`expr "$LOOKUP" : '.*-> \(.*\)$'`;
    if expr "${TARGET:-.}/" : '/.*/$' > /dev/null; then
        SOURCE=${TARGET:-.};
    else
        SOURCE=`dirname "$SOURCE"`/${TARGET:-.};
    fi;
done;
PREFIX=`dirname "$SOURCE"`/..;
prefix=$PREFIX;
PREFIX=`cd "$PREFIX"; pwd`;

QUICK="$PREFIX/build/quick/bin/"
if [ -d "$PREFIX/dists" ]; then
    LATEST="$PREFIX/dists/latest/bin/";
else
    if [ -d "$PREFIX/build" ]; then
        LATEST="$QUICK";
    else
        LATEST="$PREFIX/bin/";
    fi;
fi;
BIN_DIR="$LATEST"

if [ -n "`which mktemp`" ] ; then
    TMP_DIR=`mktemp -d`
else
    TMP_DIR=${TMPDIR-/tmp}/tmp-$USER.`basename $0`
fi

if [ -d "$PREFIX/test" ]; then
    TEST_DIR="$PREFIX/test";
elif [ -d "$PREFIX/misc/scala-test" ]; then
    TEST_DIR="$PREFIX/misc/scala-test";
else
    abort "Test directory not found";
fi;
SOURCE_DIR=$TEST_DIR/files/cli
OUTPUT_DIR=$TMP_DIR/classes
API_DIR=$TMP_DIR/api

DIFF="diff";
RM="rm -f";
TREE="tree";

case `uname` in
    CYGWIN* )
        DIFF="diff --text --strip-trailing-cr";
        ;;
esac;

DEBUG="";
LANG="scala";
SUFFIX=".scala";
COMPILER="scalac";
LEVEL="";
while [ $# -gt 0 ]; do
    case "$1" in
        --debug    ) DEBUG="debug"; LEVEL="verbose"; shift 1;;
        --quick    ) BIN_DIR="$QUICK"; shift 1;;
        --installed) BIN_DIR=""; shift 1;;
        --info     ) LEVEL="info"; shift 1;;
        --javac    ) LANG="java"; SUFFIX=".java"; COMPILER="javac"; shift 1;;
        --jikes    ) LANG="java"; SUFFIX=".java"; COMPILER="jikes"; shift 1;;
        --jredir=* ) JRE_DIR=`expr "$1" : "--jredir=\(.*\)"`; shift 1;;
        --objdir=* ) OUTPUT_DIR=`expr "$1" : "--objdir=\(.*\)"`; shift 1;;
        --verbose  ) LEVEL="verbose"; shift 1;;
        --help     ) test_print_help; exit 0;;
        --version  ) test_print_version; exit 0;;
        -*         ) abort "unknown option $1";;
        *          ) test_add_file "$1"; shift 1;; #test_print_usage; exit 0;;
    esac;
done;

if [ "$LANG" = "scala" ]; then
    RUNTIME_COMMAND="${BIN_DIR}scala";
    COMPILER_COMMAND="${BIN_DIR}$COMPILER";
    INTERPRETER_COMMAND="${BIN_DIR}scala";
    DOCGEN_COMMAND="${BIN_DIR}scaladoc";
elif [ "$LANG" = "java" ]; then
    RUNTIME_COMMAND=`which ${JAVACMD:=java}`
    BIN_DIR=`dirname $RUNTIME_COMMAND`;
    [ "$COMPILER" = "javac" ] && COMPILER_COMMAND=$BIN_DIR/$COMPILER;
    [ "$COMPILER" = "jikes" ] && COMPILER_COMMAND=`which $COMPILER`;
    DOCGEN_COMMAND=`dirname "$COMPILER_COMMAND"`/javadoc;
else
    abort "unknown language '$LANG'"
fi
[ -x "$COMPILER_COMMAND" ] || abort "Command $COMPILER_COMMAND not found";
[ -x "$RUNTIME_COMMAND"  ] || abort "Command $RUNTIME_COMMAND not found";

printf_initialization "${COLOR:-many}";

printf_outline "Output directory is : $OUTPUT_DIR\\n";
printf_outline "Compiler command is : $COMPILER_COMMAND\\n";
printf_outline "Runtime command is  : $RUNTIME_COMMAND\\n";

jvm_version=`${JAVACMD:=java} -version 2>&1 | head -3 | tail -1`
printf_outline "Java runtime is     : $jvm_version\\n";
if [ "$LANG" = "scala" ]; then
    [ `echo "$jvm_version" | grep -c "J9"` = "1" ] && LANG="${LANG}_j9";
elif [ "$LANG" = "java" ]; then
    if [ "$COMPILER" = "jikes" ]; then
         if [ "$LANG" = "java" ]; then
             jre_home=`dirname $RUNTIME_COMMAND`/..;
         elif [ -n "$JRE_DIR" ]; then
             jre_home=$JRE_DIR;
         else
             abort "Jikes requires Sun JVM (use option '--jredir')";
         fi;
         cpath=`find $jre_home -name "rt.jar"`;
         COMPILER_COMMAND="${COMPILER_COMMAND} -bootclasspath $cpath";
    fi;
    [ `echo "$jvm_version" | grep -c "1\.5"` = "1" ] && LANG="${LANG}5";
    [ `echo "$jvm_version" | grep -c "1\.6"` = "1" ] && LANG="${LANG}6";
    [ `echo "$jvm_version" | grep -c "J9"` = "1" ] && LANG="${LANG}_j9";
fi

if [ "$DEBUG" = "debug" ] ; then
    LOG_FILE=/dev/tty
else
    LOG_FILE=${TMP_DIR}/${SCRIPT}.log
fi
DIFF_FILE=${TMP_DIR}/${SCRIPT}.diff
TMP_FILE=${TMP_DIR}/${SCRIPT}.tmp

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

if [ -z "$FILES" ]; then
    FILES=`find "$SOURCE_DIR" -name "Main$SUFFIX" -a -type f -print`;
fi;
for testfile in "" $FILES; do
    [ -z "$testfile" ] && continue;
    checkfile=`dirname "$testfile"`/`basename "$testfile" "$SUFFIX"`.check
    info=`awk '$1 ~ /^\/\//{i=index($0,"@info ");if(i>0){print substr($0,i+6)}}' "$testfile"`;
    test_compile "$testfile" "$checkfile" "$info";
    if [ "$?" = "0" ] ; then
        scala_main=`echo "$testfile" | \
            sed -e "s#${SOURCE_DIR}/\(.*\)\${SUFFIX}#\1#g" -e "s#\/#\.#g"`;
        test_execute "$scala_main" "$checkfile";
        test_interpret "$scala_main" "$checkfile";
        test_docgen "$testfile" "$checkfile";
    fi
done;

##############################################################################
# Epilog

$RM -r $TMP_DIR

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