498 lines
16 KiB
Bash
Executable File
498 lines
16 KiB
Bash
Executable File
#!/bin/sh
|
|
##############################################################################
|
|
# __ #
|
|
# ________ ___ / / ___ Scala Tools Launch Script #
|
|
# / __/ __// _ | / / / _ | (c) 2002-2007, LAMP/EPFL #
|
|
# __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ #
|
|
# /____/\___/_/ |_/____/_/ | | #
|
|
# |/ #
|
|
##############################################################################
|
|
|
|
# $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
|
|
|
|
##############################################################################
|