#!/bin/sh
##############################################################################
# __ #
# ________ ___ / / ___ Scala Tools Launch Script #
# / __/ __// _ | / / / _ | (c) 2002-2003, LAMP/EPFL #
# __\ \/ /__/ __ |/ /__/ __ | #
# /____/\___/_/ |_/____/_/ | | #
# |/ #
##############################################################################
# $Id$
##############################################################################
# Configuration
# The configure function contains all the configurable variables of
# this script. Each of these variables may be overridden by defining
# an environment variable with the same but where the "default_" has
# been replaced by "SCALA_". For example, to start scalaint with a big
# initial heap size, one may run the following command:
#
# env SCALA_SCALA_ARGS=-Xms1024m scalaint".
#
# These variables must use the Unix form for paths and path lists
# (i.e. use '/' as file separator and ':' as path separator). There
# are two exceptions: JAVA_ARGS and SCALA_ARGS which must use the
# paltform-specific form.
#
# The following environment variables are also read by this script:
#
# - SCALA_CLASSPATH: if defined, it is used as the default classpath
# by all Scala tools.
#
# - CLASSPATH: if defined and SCALA_CLASSPATH is undefined, it is used
# as the default classpath by all Scala tools.
#
# - SCALA_SOURCEPATH: if defined, it is used as the default sourcepath
# by all Scala tools.
#
# - SCALA_BOOTCLASSPATH: if defined, it is used as the default
# bootclasspath by all Scala tools.
#
# - SCALA_EXTDIRS: if defined, it is used as the default extdirs by
# all Scala tools.
#
# These variables must use the platform-specific form for paths and
# path lists.
configure() {
# Location of the Scala library sources.
default_LIBRARY_SOURCES={#LIBRARY_SOURCES#};
# Location of the Scala library.
default_LIBRARY_CLASSES={#LIBRARY_CLASSES#};
# Location of the Scala tools library.
default_TOOLS_CLASSES={#TOOLS_CLASSES#};
# Location of the FJBG library.
default_FJBG_CLASSES={#FJBG_CLASSES#};
# Location of the MSIL library.
default_MSIL_CLASSES={#MSIL_CLASSES#};
# Command to start the Java VM.
default_JAVA_CMD={#JAVA_CMD#};
# Additional arguments to pass to the Java VM.
default_JAVA_ARGS={#JAVA_ARGS#};
# Command to start the Scala VM.
default_SCALA_CMD={#SCALA_CMD#};
# Additional arguments to pass to the Scala VM.
default_SCALA_ARGS={#SCALA_ARGS#};
# Command to start subprocesses. This is mainly for debugging
# purposes. For example, one may display the Java command that is
# started by "scala", by running "env SCALA_EXEC=echo scala".
default_EXEC="exec";
}
##############################################################################
# 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;
}
# Prints formated text in success font.
printf_success() {
$printf_font_success;
printf "$@";
$printf_font_default;
}
# Prints formated text in failure font.
printf_failure() {
$printf_font_failure;
printf "$@";
$printf_font_default;
}
# Prints formated text in warning font.
printf_warning() {
$printf_font_warning;
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;
}
##############################################################################
# Path list construction functions
# Prints the concatenation of two path lists.
append_pathlists() {
[ $# = 2 ] || abort "internal error";
if [ -z "$1" ]; then
echo "$2";
elif [ -z "$2" ]; then
echo "$1";
else
echo "$1:$2";
fi;
}
##############################################################################
# Value computation functions
# Computes and stores the value "$1" in the variable "current_$1". If
# the variable "SCALA_$1" is defined, its content is used. Otherwise,
# the content of the variable "default_$1" is used.
compute_value() {
[ $# = 1 ] || abort "internal error";
eval current_$1=\"\$default_$1\";
case "$1" in
LIBRARY_SOURCES | \
LIBRARY_CLASSES | \
TOOLS_CLASSES | \
FJBG_CLASSES | \
MSIL_CLASSES )
if eval [ -n \"\$SCALA_$1\" ]; then
if eval [ -f \"\$SCALA_$1\" -o -d \"\$SCALA_$1\" ]; then
eval current_$1=\"\$SCALA_$1\";
else
eval warning \""File referred by SCALA_$1 (\$SCALA_$1)" \
"does not exist, using default value instead."\";
unset SCALA_$1;
fi;
fi;
if eval [ -f \"\$current_$1\" -o -d \"\$current_$1\" ]; then
:;
else
eval abort \""File referred by default_$1 (\$default_$1)" \
"does not exist. Please, fix definition of default_$1 in" \
"file $SOURCE or define environment variable SCALA_$1."\";
fi;
;;
JAVA_CMD | \
JAVA_ARGS | \
SCALA_CMD | \
SCALA_ARGS | \
EXEC )
if eval [ -n \"\$SCALA_$1\" ]; then
eval current_$1=\"\$SCALA_$1\";
fi;
;;
* )
abort "internal error: $1";
;;
esac;
}
##############################################################################
# Default paths
# Prints the default scala classpath or nothing if it's unspecified.
get_scala_classpath() {
if [ -n "$SCALA_CLASSPATH" ]; then
get_unix_pathlist "$SCALA_CLASSPATH";
elif [ -n "$CLASSPATH" ]; then
get_unix_pathlist "$CLASSPATH";
fi;
}
# Prints the default scala sourcepath or nothing if it's unspecified.
get_scala_sourcepath() {
if [ -n "$SCALA_SOURCEPATH" ]; then
get_unix_pathlist "$SCALA_SOURCEPATH";
fi;
}
# Prints the default scala bootclasspath or nothing if it's unspecified.
get_scala_bootclasspath() {
if [ -n "$SCALA_BOOTCLASSPATH" ]; then
get_unix_pathlist "$SCALA_BOOTCLASSPATH";
fi;
}
# Prints the default scala extdirs or nothing if it's unspecified.
get_scala_extdirs() {
if [ -n "$SCALA_EXTDIRS" ]; then
get_unix_pathlist "$SCALA_EXTDIRS";
fi;
}
##############################################################################
# VM invocation functions
# Prints the VM script-suffix-specific arguments.
vm_get_script_suffix_args() {
case "$SCRIPT" in
*-debug* ) echo "-Djava.compiler=NONE -ea";;
esac;
}
# Starts a Java VM with the specified arguments.
vm_start_java() {
# compute values
compute_value EXEC;
compute_value JAVA_CMD;
compute_value JAVA_ARGS;
# start Java VM
$current_EXEC $current_JAVA_CMD $current_JAVA_ARGS \
`vm_get_script_suffix_args` "$@";
}
# Starts a Scala VM with the specified arguments.
vm_start_scala() {
# compute values
compute_value EXEC;
compute_value SCALA_CMD;
compute_value SCALA_ARGS;
# start Java VM
$current_EXEC $current_SCALA_CMD $current_SCALA_ARGS \
`vm_get_script_suffix_args` "$@";
}
##############################################################################
# Scala invocation functions
# Returns true if the given arguments contain a flag -Xbootclasspath.
scala_has_bootclasspath() {
while [ $# != 0 ]; do
case "$1" in
-Xbootclasspath:* ) return 0;;
-cp | -classpath ) shift 2;;
-jar ) return 1;;
-* ) shift 1;;
* ) return 1;;
esac;
done;
return 1;
}
# Implements "scala [<option>...] <class> [<args>...]".
scala_main() {
if scala_has_bootclasspath "$@"; then
vm_start_java "$@";
else
compute_value LIBRARY_CLASSES;
classes="$current_LIBRARY_CLASSES";
vm_start_java "-Xbootclasspath/a:`get_os_filename "$classes"`" "$@";
fi;
}
##############################################################################
# Tool invocation functions
# Starts a Scala tool. The first argument is added to the runtime
# classpath. The following ones are passed to vm_start_scala. They
# must, at least, contain the name of the main class.
tool_start() {
[ $# -gt 1 ] || abort "internal error";
classpath="$1"; shift 1;
# compute value
compute_value LIBRARY_SOURCES;
compute_value LIBRARY_CLASSES;
compute_value TOOLS_CLASSES;
# append tools library to classpath
classpath=`append_pathlists "$classpath" "$current_TOOLS_CLASSES"`;
# start Scala VM
tool_start0 -classpath "`get_os_pathlist "$classpath"`" "$@";
}
tool_start0() {
if [ -n "`get_scala_extdirs`" ]; then
tool_start1 -Dscala.ext.dirs="`get_scala_extdirs`" "$@";
else
tool_start1 "$@";
fi;
}
tool_start1() {
if [ -n "`get_scala_bootclasspath`" ]; then
tool_start2 -Dscala.boot.class.path="`get_scala_bootclasspath`" "$@";
else
tool_start2 "$@";
fi;
}
tool_start2() {
if [ -n "`get_scala_sourcepath`" ]; then
tool_start3 -Dscala.source.path="`get_scala_sourcepath`" "$@";
else
tool_start3 "$@";
fi;
}
tool_start3() {
if [ -n "`get_scala_classpath`" ]; then
tool_start4 -Dscala.class.path="`get_scala_classpath`" "$@";
else
tool_start4 "$@";
fi;
}
tool_start4() {
sources="$current_LIBRARY_SOURCES";
classes="$current_LIBRARY_CLASSES";
vm_start_scala \
-Dscala.product="$SCRIPT" \
-Dscala.version="$VERSION" \
-Dscala.home="$PREFIX" \
-Dscala.library.source.path="`get_os_filename "$sources"`" \
-Dscala.library.class.path="`get_os_filename "$classes"`" \
"$@";
}
##############################################################################
# Compiler invocation functions
# Starts a Scala compiler. The first argument is added to the runtime
# classpath. The following ones are passed to vm_start_scala. They
# must, at least, contain the name of the main class.
compiler_start() {
[ $# -gt 1 ] || abort "internal error";
classpath="$1"; shift 1;
# compute values
compute_value FJBG_CLASSES;
compute_value MSIL_CLASSES;
# append FJBG and MSIL libraries to classpath
classpath=`append_pathlists "$classpath" "$current_FJBG_CLASSES"`;
classpath=`append_pathlists "$classpath" "$current_MSIL_CLASSES"`;
# start tool
tool_start "$classpath" "$@";
}
##############################################################################
# Implementation of scala-info
# Prints given error message, prints usage and exits with error code 1.
info_abort() {
error "$@";
info_print_usage 1>&2;
exit 1;
}
# Prints value of variable $1.
info_print_variable() {
[ $# = 1 ] || abort "internal error";
eval echo \"\$$1\";
}
# Prints default value of value $1.
info_print_default_value() {
[ $# = 1 ] || abort "internal error";
info_print_variable "default_$1";
}
# Prints current value of value $1.
info_print_current_value() {
[ $# = 1 ] || abort "internal error";
compute_value "$1";
info_print_variable "current_$1";
}
# Implements "scala-info --home".
info_option_home() {
[ $# -gt 0 ] && abort "too many arguments";
echo "$PREFIX";
}
# Implements "scala-info --version".
info_option_version() {
[ $# -gt 0 ] && abort "too many arguments";
echo "$VERSION";
}
# Implements "scala-info --$1 <value>"
info_option_x_value() {
[ $# -lt 2 ] && abort "missing value name";
[ $# -gt 2 ] && abort "too many arguments";
case "$2" in
LIBRARY_SOURCES ) value=$2;;
LIBRARY_CLASSES ) value=$2;;
TOOLS_CLASSES ) value=$2;;
FJBG_CLASSES ) value=$2;;
MSIL_CLASSES ) value=$2;;
JAVA_CMD ) value=$2;;
JAVA_ARGS ) value=$2;;
SCALA_CMD ) value=$2;;
SCALA_ARGS ) value=$2;;
EXEC ) value=$2;;
* ) abort "Unknown value \`$2'";;
esac;
info_print_$1_value $value;
}
# Implements "scala-info --help".
info_option_help() {
echo "usage: $0 <option>";
echo "where possible options include:";
echo " --home Print Scala home directory";
echo " --version Print Scala version";
echo " --default <name> Print default value of value <name>";
echo " --current <name> Print current value of value <name>";
echo " -? --help Print this help message";
echo "";
echo "valid value names include:";
echo " LIBRARY_SOURCES Location of the Scala library sources";
echo " LIBRARY_CLASSES Location of the Scala library";
echo " TOOLS_CLASSES Location of the Scala tools";
echo " FJBG_CLASSES Location of the fjbg library";
echo " MSIL_CLASSES Location of the msil library";
echo " JAVA_CMD Command to start the Java VM";
echo " JAVA_ARGS Additional arguments to pass to the Java VM";
echo " SCALA_CMD Command to start the Scala VM";
echo " SCALA_ARGS Additional arguments to pass to the Scala VM";
echo " EXEC Command to start subprocesses";
}
# Implements "scala-info <option>".
info_main() {
[ $# = 0 ] && abort "missing option";
case "$1" in
--home ) shift 1; info_option_home "$@";;
--version ) shift 1; info_option_version "$@";;
--default ) shift 1; info_option_x_value default "$@";;
--current ) shift 1; info_option_x_value current "$@";;
-? | --help ) shift 1; info_option_help "$@";;
-* ) abort "unrecognised option \`$1'";;
* ) abort "illegal argument \`$1'";;
esac;
}
##############################################################################
# Implementation of scalatest
# Prints the scalatest usage.
test_print_usage() {
[ $# = 0 ] || abort "internal error";
echo "Usage: $0 [OPTION]..."
}
# Prints the scalatest help.
test_print_help() {
[ $# = 0 ] || abort "internal error";
test_print_usage;
echo "";
echo "--auto use filenames to select the test to run";
echo "--run next files test the interpreter and all backends";
echo "--jvm next files test the jvm backend";
echo "--int next files test the interpreter";
echo "--shl next files test the interpreter shell";
echo "--xml next files test the dtd2scala tool";
echo "--dis next files test the disassembler";
echo "--pos next files test a compilation success";
echo "--neg next files test a compilation failure";
echo "--msil next files test the .NET backend";
echo "--no-run run no test, use results of last run";
echo "--show-log show output of failed tests";
echo "--show-diff show differences between actual and expected output";
echo "--failed test only files that failed last time";
echo "--errors=<int> specify the number of expected errors";
echo "--flags=<flags> specify flags to pass on to the executable";
echo "--color=USAGE control the color usage (USAGE=none|some|many)";
echo "--objdir=<dir> specify where to place generated files";
echo "--help, -? display this help and exit";
echo "--version output version information and exit";
}
# Prints the scalatest version.
test_print_version() {
[ $# = 0 ] || abort "internal error";
echo "$SCRIPT $Revision$";
}
# Prints the name of the specified test file.
test_print_testing() {
[ $# = 1 ] || abort "internal error";
printf_outline "testing: ";
if [ -n "$BASH" ]; then
case "$1" in
"$TESTROOT"* )
printf "%-60s " "[...]${1#$TESTROOT}";
return 0;
;;
esac;
fi;
printf "%-60s " "$1";
}
# Prints a test success notification.
test_print_success() {
[ $# = 0 ] || abort "internal error";
printf "[";
printf_success " OK ";
printf "]\\n";
}
# Prints a test failure notification.
test_print_failure() {
[ $# = 0 ] || abort "internal error";
printf "[";
printf_failure "FAILED";
printf "]\\n";
}
test_check_interpretation() {
$SURUS $TEST_FLAGS $FLAGS "$source" -- Test "int";
}
test_check_shell() {
cat "$source" | $SURUS -interactive -nologo $TEST_FLAGS $FLAGS;
}
test_check_compilation() {
output="$OBJDIR"`expr "$source" : "\(.*\)\\.scala"`-$KIND.obj;
classpath=`get_os_pathlist "$output"`;
os_output=`get_os_filename "$output"`;
rm -rf "$output";
mkdir -p "$output" &&
$SOCOS -d "$os_output" $TEST_FLAGS $FLAGS "$source" &&
$SCALA -classpath "$classpath" Test "jvm" &&
rm -rf "$output";
}
test_check_xml() {
output="$OBJDIR"`expr "$source" : "\(.*\)\\.scala"`-$KIND.obj;
dtdfile="`expr "$source" : "\(.*\)\\.scala"`.dtd";
xmlfile="`expr "$source" : "\(.*\)\\.scala"`.xml";
nsfile="`expr "$source" : "\(.*\)\\.scala"`.namespace";
objfile="$output/dtd.scala";
classpath=`get_os_pathlist "$output"`;
os_output=`get_os_filename "$output"`;
rm -rf "$output";
mkdir -p "$output" &&
$DTD2SCALA -d "$os_output" "$dtdfile" dtd `cat $nsfile` &&
$SOCOS -d "$os_output" $TEST_FLAGS $FLAGS "$objfile" "$source" &&
$SCALA -classpath "$classpath" Test "$xmlfile" &&
rm -rf "$output";
}
test_check_disassembler() {
scalapargs="`expr "$source" : "\(.*\)\\.scala"`.args";
if [ -f "$scalapargs" ]; then
SCALAP_ARGS=`cat "$scalapargs"`;
else
SCALAP_ARGS="";
fi;
output="$OBJDIR"`expr "$source" : "\(.*\)\\.scala"`-$KIND.obj;
classpath=`get_os_pathlist "$output"`;
os_output=`get_os_filename "$output"`;
rm -rf "$output";
mkdir -p "$output" &&
$SOCOS -d "$os_output" $TEST_FLAGS $FLAGS "$source" &&
$SCALAP -classpath "$classpath" $SCALAP_ARGS &&
rm -rf "$output";
}
test_check_compilation_success() {
output="$OBJDIR"`expr "$source" : "\(.*\)\\.scala"`-$KIND.obj;
os_output=`get_os_filename "$output"`;
rm -rf "$output";
mkdir -p "$output" &&
$SOCOS -d "$os_output" $TEST_FLAGS $FLAGS "$source" &&
rm -rf "$output";
}
test_check_compilation_failure() {
(
OBJDIR="$OBJDIR"`dirname "$source"`;
cd `dirname "$source"`;
source=`basename "$source"`;
if test_check_compilation_success "$@"; then false; else
rm -rf "$output";
fi;
)
}
test_check_msil() {
ASSEM="Test"
IL_FILE=${ASSEM}".il"
PE_FILE=${ASSEM}".EXE"
ILASM=ilasm
ILASM_ARGS="/qui /nol /out=${PE_FILE}"
PEVERIFY=peverify
PEVERIFY_ARGS="/il"
rm -f $IL_FILE
rm -f $PE_FILE
$SOCOS -nowarn -target:msil -o ${ASSEM} $FLAGS "$source" &&
${ILASM} ${ILASM_ARGS} ${IL_FILE} > /dev/null &&
if [ ! $? ] ; then
echo "'$ILASM' failed!"
return 1
fi
# $PEVERIFY $PEVERIFY_ARGS $PE_FILE > /dev/null
# if [ ! $? ] ; then
# echo "'$PEVERIFY' failed!"
# rm -rf $PE_FILE
# return 1
# fi
eval ./$PE_FILE "msil"
}
test_check_output() {
if [ -f "$expect" ]; then
$DIFF "$actual" "$expect";
else
cat /dev/null | $DIFF "$actual" -;
fi;
}
test_check_file() {
source="$FILE";
flags="`expr "$source" : "\(.*\)\\.scala"`.flags";
expect="`expr "$source" : "\(.*\)\\.scala"`-$KIND.check";
if [ ! -f $expect ]; then
expect="`expr "$source" : "\(.*\)\\.scala"`.check";
fi;
actual="$OBJDIR""`expr "$source" : "\(.*\)\\.scala"`-$KIND.log";
if [ -f "$flags" ]; then
TEST_FLAGS=`cat $flags`;
else
TEST_FLAGS="";
fi;
if [ "$FAILED" = "true" -a ! -f "$actual" ]; then
continue;
fi;
if [ "$HEAD" != "true" ]; then
printf_outline "$TEXT\\n";
HEAD="true";
fi;
test_print_testing "$FILE";
if [ "$NORUN" != "true" ]; then
rm -f "$actual";
"$TEST" 1> "$actual" 2>&1 && test_check_output 1> /dev/null 2>&1;
else
test ! -f "$actual";
fi;
if [ "$?" = 0 ]; then
SUCCESS_COUNT=`echo "$SUCCESS_COUNT+1" | bc`;
test_print_success;
rm -f "$actual";
else
FAILURE_COUNT=`echo "$FAILURE_COUNT+1" | bc`;
test_print_failure;
fi;
if [ -f "$actual" ]; then
if [ "$SHOWLOG" = "true" ]; then
cat "$actual";
fi;
if [ "$SHOWDIFF" = "true" ]; then
test_check_output;
fi;
fi;
}
test_check_one() {
HEAD="false";
TEXT="$1"; shift 1;
TEST="$1"; shift 1;
KIND="$1"; shift 1;
for FROM do
if [ -d "$FROM" -o -f "$FROM" ]; then
for FILE in . `find "$FROM" -name "*.obj" -prune -o -name "*.scala" -print`; do
if [ "$FILE" = "." ]; then continue; fi;
test_check_file;
done;
fi;
done
if [ "$HEAD" = "true" ]; then
echo "";
fi;
}
test_check_all() {
test_check_one "Testing jvm backend" \
test_check_compilation "jvm" $FILES_RUN $FILES_JVM;
test_check_one "Testing interpreter shell" \
test_check_shell "shl" $FILES_SHL;
test_check_one "Testing disassembler" \
test_check_disassembler "dis" $FILES_DIS;
test_check_one "Testing dtd2scala tool" \
test_check_xml "xml" $FILES_XML;
test_check_one "Testing compiler (on files whose compilation should succeed)" \
test_check_compilation_success "pos" $FILES_POS;
test_check_one "Testing compiler (on files whose compilation should fail)" \
test_check_compilation_failure "neg" $FILES_NEG;
test_check_one "Testing msil backend" \
test_check_msil "msil" $FILES_MSIL;
test_check_one "Testing interpreter" \
test_check_interpretation "int" $FILES_RUN $FILES_INT;
}
test_add_file() {
TEST_ALL="false";
case "$TEST_TYPE" in
auto ) ;;
run ) FILES_RUN="$FILES_RUN $1"; return;;
jvm ) FILES_JVM="$FILES_JVM $1"; return;;
int ) FILES_INT="$FILES_INT $1"; return;;
shl ) FILES_SHL="$FILES_SHL $1"; return;;
xml ) FILES_XML="$FILES_XML $1"; return;;
dis ) FILES_DIS="$FILES_DIS $1"; return;;
pos ) FILES_POS="$FILES_POS $1"; return;;
neg ) FILES_NEG="$FILES_NEG $1"; return;;
msil ) FILES_MSIL="$FILES_MSIL $1"; return;;
* ) abort "unknown test type \`$TEST_TYPE'";;
esac;
case "$1" in
run | */run | */run/* | run/* ) FILES_RUN="$FILES_RUN $1";;
jvm | */jvm | */jvm/* | jvm/* ) FILES_JVM="$FILES_JVM $1";;
int | */int | */int/* | int/* ) FILES_INT="$FILES_INT $1";;
shl | */shl | */shl/* | shl/* ) FILES_SHL="$FILES_SHL $1";;
xml | */xml | */xml/* | xml/* ) FILES_XML="$FILES_XML $1";;
dis | */dis | */dis/* | dis/* ) FILES_DIS="$FILES_DIS $1";;
pos | */pos | */pos/* | pos/* ) FILES_POS="$FILES_POS $1";;
neg | */neg | */neg/* | neg/* ) FILES_NEG="$FILES_NEG $1";;
msil | */msil | */msil/* | msil/* ) FILES_MSIL="$FILES_MSIL $1";;
* ) abort "don't known what to do with \`$1'";;
esac;
}
# Implements "scalatest ...".
test_main() {
if [ "$SCALATEST" = "java" ]; then
tool_start "" scala.tools.scalatest.Main "$@";
fi;
configure;
NORUN="false";
SHOWLOG="false";
SHOWDIFF="false";
FAILED="false";
ERRORS=0;
SUCCESS_COUNT=0;
FAILURE_COUNT=0;
TESTROOT=`dirname "$default_LIBRARY_SOURCES"`;
SRCDIR={#TEST_SRCDIR#};
OBJDIR={#TEST_OBJDIR#};
TEST_ALL="true";
TEST_TYPE="auto";
FILES_RUN="";
FILES_JVM="";
FILES_INT="";
FILES_SHL="";
FILES_XML="";
FILES_DIS="";
FILES_POS="";
FILES_NEG="";
FILES_MSIL="";
SCALA="$PREFIX/bin/scala";
SOCOS="$PREFIX/bin/scalac";
SURUS="$PREFIX/bin/scalarun";
SCALAP="$PREFIX/bin/scalap";
DTD2SCALA="$PREFIX/bin/dtd2scala";
DIFF="diff";
case `uname` in
CYGWIN* )
DIFF="diff --text --strip-trailing-cr";
;;
esac;
while [ $# -gt 0 ]; do
case "$1" in
--auto ) TEST_TYPE="auto"; shift 1;;
--run ) TEST_TYPE="run"; shift 1;;
--jvm ) TEST_TYPE="jvm"; shift 1;;
--int ) TEST_TYPE="int"; shift 1;;
--shl ) TEST_TYPE="shl"; shift 1;;
--xml ) TEST_TYPE="xml"; shift 1;;
--dis ) TEST_TYPE="dis"; shift 1;;
--pos ) TEST_TYPE="pos"; shift 1;;
--neg ) TEST_TYPE="neg"; shift 1;;
--msil ) TEST_TYPE="msil"; shift 1;;
--no-run ) NORUN="true"; shift 1;;
--show-log ) SHOWLOG="true"; shift 1;;
--show-diff ) SHOWDIFF="true"; shift 1;;
--failed ) FAILED="true"; shift 1;;
--errors= ) abort "illegal empty argument for option --errors";;
--errors=* )ERRORS=`expr "$1" : "--errors=\([0-9]*\)$"`;shift 1;;
--flags= ) abort "illegal empty argument for option --flags";;
--flags=* ) FLAGS=`expr "$1" : "--flags=\(.*\)"`; shift 1;;
--color= ) abort "illegal empty argument for option --color";;
--color=* ) COLOR=`expr "$1" : "--color=\(.*\)"`; shift 1;;
--objdir=* ) OBJDIR=`expr "$1" : "--objdir=\(.*\)"`; shift 1;;
--help| -? ) print_help; exit 0;;
--version ) print_version; exit 0;;
-* ) abort "unknown option $1";;
* ) add_file "$1"; shift 1;;
esac;
done;
if [ -z "$ERRORS" ]; then
abort "illegal non-numerical argument for option --errors";
fi;
if [ -z "$COLOR" -a -n "$EMACS" ]; then
COLOR="none";
fi;
printf_initialization "${COLOR:-many}";
if [ "$TEST_ALL" = "true" ]; then
case "$TEST_TYPE" in
run ) FILES_RUN="$FILES_RUN $SRCDIR/run";;
esac;
case "$TEST_TYPE" in
auto | jvm ) FILES_JVM="$FILES_JVM $SRCDIR/run $SRCDIR/jvm";;
esac;
case "$TEST_TYPE" in
auto | int ) FILES_INT="$FILES_INT $SRCDIR/run";;
esac;
case "$TEST_TYPE" in
auto | shl ) FILES_SHL="$FILES_SHL $SRCDIR/shl";;
esac;
case "$TEST_TYPE" in
auto | xml ) FILES_XML="$FILES_XML $SRCDIR/xml";;
esac;
case "$TEST_TYPE" in
auto | dis ) FILES_DIS="$FILES_DIS $SRCDIR/dis";;
esac;
case "$TEST_TYPE" in
auto | pos ) FILES_POS="$FILES_POS $SRCDIR/pos";;
esac;
case "$TEST_TYPE" in
auto | neg ) FILES_NEG="$FILES_NEG $SRCDIR/neg";;
esac;
case "$TEST_TYPE" in
msil ) FILES_MSIL="$FILES_MSIL $SRCDIR/run";;
esac;
fi;
if [ -n "$OBJDIR" ]; then
if [ -d "$OBJDIR" ] || mkdir -p "$OBJDIR"; then
OBJDIR=`cd "$OBJDIR"; pwd`/;
else
abort "could not create directory '$OBJDIR'";
fi
fi
test_check_all;
if [ $FAILURE_COUNT -eq 0 ]; then
printf_success "All tests were successful\\n";
elif [ $FAILURE_COUNT -eq 1 ]; then
printf_failure "There was 1 test that failed\\n";
else
printf_failure "There were $FAILURE_COUNT tests that failed\\n";
fi;
if [ $FAILURE_COUNT -eq "$ERRORS" ]; then
exit 0;
else
exit 1;
fi;
}
##############################################################################
# Definition of UNAME, SOURCE, SCRIPT, PREFIX and VERSION
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`;
VERSION={#VERSION#};
VERSION=${VERSION:-"unknown version"};
##############################################################################
# Test of invocation method
if [ -z "$SCRIPT" ]; then
abort "Illegal direct invocation; invoke me through a symbolic link.";
fi;
##############################################################################
# Configuration and invocation of $SCRIPT
configure;
case "$SCRIPT" in
scala-info ) info_main "$@";;
scala ) scala_main "$@";;
scala-* ) scala_main "$@";;
scalac* ) compiler_start "" scala.tools.scalac.Main "$@";;
scalarun* ) compiler_start "" scala.tools.scalai.Main "$@";;
scalaint* ) compiler_start "" scala.tools.scalai.Main -interactive "$@";;
scaladoc* ) tool_start "" scala.tools.scaladoc.Main "$@";;
scalap* ) tool_start "" scala.tools.scalap.Main "$@";;
dtd2scala* ) tool_start "" scala.tools.dtd2scala.Main "$@";;
scalatest* ) test_main "$@";;
* ) abort "Don't know what to do for $SCRIPT.";;
esac;
##############################################################################