diff options
Diffstat (limited to 'bin')
-rwxr-xr-x | bin/scalanstest | 1060 |
1 files changed, 1060 insertions, 0 deletions
diff --git a/bin/scalanstest b/bin/scalanstest new file mode 100755 index 0000000000..cc573b7fdb --- /dev/null +++ b/bin/scalanstest @@ -0,0 +1,1060 @@ +#!/bin/sh +############################################################################## +# __ # +# ________ ___ / / ___ Scala Tools Launch Script # +# / __/ __// _ | / / / _ | (c) 2002-2005, 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="/home/dragos/scala/sources"; + + # Location of the Scala library. + default_LIBRARY_CLASSES="$PREFIX/build/nslib"; + + # Location of the Scala tools library. + default_TOOLS_CLASSES="$PREFIX/build/nslib"; + + # Location of the FJBG library. + default_FJBG_CLASSES="/home/linuxsoft/apps/fjbg/jars/fjbg.jar"; + + # Location of the MSIL library. + default_MSIL_CLASSES="/home/linuxsoft/apps/msil/msil.jar"; + + # Command to start the Java VM. + default_JAVA_CMD="java"; + + # Additional arguments to pass to the Java VM. + default_JAVA_ARGS="-enableassertions"; + + # Command to start the Scala VM. + default_SCALA_CMD="$PREFIX/bin/ns"; + + # Additional arguments to pass to the Scala VM. + default_SCALA_ARGS="-enableassertions"; + + # 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 | \ + NLIBRARY_CLASSES | \ + NTOOLS_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 1; [ $# != 0 ] && shift 1;; + -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;; + NLIBRARY_CLASSES ) value=$2;; + NTOOLS_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 " NLIBRARY_CLASSES Location of the new Scala library"; + echo " NTOOLS_CLASSES Location of the new 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 "--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: "; + case "$1" in + "$TESTROOT"* ) + printf "%-60s " "[...]`expr "$1" : "$TESTROOT\(.*\)"`"; + return 0; + ;; + esac; + 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"; +} + + +# Tests a compilation success. +test_run_pos() { + rm -rf "$dstbase".obj && + mkdir -p "$dstbase".obj && + $SOCOS -d "$os_dstbase".obj "$@" "$os_srcbase".scala && + rm -rf "$dstbase".obj; +} + +# Tests a compilation failure. +test_run_neg() { + rm -rf "$dstbase".obj && + mkdir -p "$dstbase".obj && + ( cd "$srcdir" && $SOCOS -d "$os_dstbase".obj "$@" "$testname".scala; ); + status=$?; + rm -rf "$dstbase".obj; + if [ "$status" = 0 ]; then return 1; else return 0; fi; +} + +# Tests the JVM backend. +test_run_jvm() { + rm -rf "$dstbase".obj && + mkdir -p "$dstbase".obj && + $SOCOS -d "$os_dstbase".obj "$@" "$os_srcbase".scala && + $SCALA -classpath "$os_dstbase".obj Test "jvm" && + rm -rf "$dstbase".obj; +} + +# Tests the interpreter. +test_run_int() { + $SURUS "$@" "$os_srcbase".scala -- Test "int"; +} + +# Tests the interpreter shell. +test_run_shl() { + cat "$os_srcbase".scala | $SURUS -interactive -nologo "$@"; +} + +# Test the disassemblers. +test_run_dis() { + argsfile="$srcbase".args; + if [ ! -f "$argsfile" ]; then + argsfile=/dev/null; + fi; + rm -rf "$dstbase".obj && + mkdir -p "$dstbase".obj && + $SOCOS -d "$os_dstbase".obj "$@" "$os_srcbase".scala && + $SCALAP -classpath "$os_dstbase".obj `cat "$argsfile"` && + rm -rf "$dstbase".obj; +} + +# Tests the .NET backend. +test_run_msil() { + assemblies=`get_os_pathlist "/home/linuxsoft/apps/msil"`; + rm -f "$dstbase".il && + rm -f "$dstbase".EXE && + $SOCOS -nowarn -target:msil -o "$os_dstbase" -r $assemblies "$@" \ + "$os_srcbase".scala && + case "$UNAME" in + CYGWIN* ) + ilasm /qui /nol /out="$os_dstbase".EXE "$os_dstbase".il \ + > /dev/null && +# peverify /il "$os_dstbase".EXE > /dev/null && + "$dstbase".EXE "msil";; + * ) + ilasm /output:"$os_dstbase".EXE "$os_dstbase".il \ + > /dev/null && + mono "$dstbase".EXE "msil";; + esac && + rm -f "$dstbase".EXE && + rm -f "$dstbase".il; +} + +# Checks the specified test. +test_check_test() { + [ $# = 1 ] || abort "internal error"; + testfile="$1"; shift 1; + # compute test name + testname=`basename "$testfile" .scala`; + + # compute source and destination directories (absolute paths) + srcdir=`dirname "$testfile"`; + srcdir=`cd "$srcdir"; pwd`; + dstdir="$OBJDIR""$srcdir"; + + # compute source and destination base names + srcbase="$srcdir"/"$testname"; + dstbase="$dstdir"/"$testname"-$kind; + os_srcbase=`get_os_filename "$srcbase"`; + os_dstbase=`get_os_filename "$dstbase"`; + + # compute flags file + flagsfile="$srcbase".flags; + if [ ! -f "$flagsfile" ]; then + flagsfile=/dev/null; + fi; + + # compute check file + checkfile="$srcbase"-$kind.check; + if [ ! -f "$checkfile" ]; then + checkfile="$srcbase".check; + fi; + if [ ! -f "$checkfile" ]; then + checkfile=/dev/null; + fi; + + # compute log file + logfile="$dstbase".log; + + # if we are testing only failed tests, skip successful tests + if [ "$FAILED" = "true" -a ! -f "$logfile" ]; then + return 0; + fi; + + # if that's the first file of the section print section header + if [ -n "$header" ]; then + printf_outline "$header\\n"; + unset header; + fi; + + # print tested file + test_print_testing "$testfile"; + + # run test + if [ "$NORUN" = "true" ]; then + [ ! -f "$logfile" ]; + else + rm -f "$logfile"; + { [ -d "$dstdir" ] || mkdir -p "$dstdir"; } && + ( test_run_$kind `cat "$flagsfile"` $FLAGS 1> "$logfile" 2>&1; ) && + $DIFF "$logfile" "$checkfile" 1> /dev/null 2>&1 && + rm -f "$logfile"; + fi; + + # print result + if [ "$?" = 0 ]; then + SUCCESS_COUNT=`echo "$SUCCESS_COUNT+1" | bc`; + test_print_success; + else + FAILURE_COUNT=`echo "$FAILURE_COUNT+1" | bc`; + test_print_failure; + if [ ! -f "$logfile" ]; then + logfile=/dev/null; + fi; + if [ "$SHOWLOG" = "true" ]; then + cat "$logfile"; + fi; + if [ "$SHOWDIFF" = "true" ]; then + $DIFF "$logfile" "$checkfile"; + fi; + fi; +} + +# Checks the specified file +test_check_file() { + [ $# = 1 ] || abort "internal error"; + file="$1"; shift 1; + for testfile in "" `find "$file" -name "*.obj" -prune -o -name "*.scala" -a -type f -print`; do + [ -z "$testfile" ] && continue; + test_check_test "$testfile"; + done; +} + +# Checks all files of the specified kind. +test_check_kind() { + [ $# -ge 2 ] || abort "internal error"; + header="$1"; shift 1; + kind="$1"; shift 1; + for file in "" "$@"; do + [ -z "$file" ] && continue; + test_check_file "$file"; + done + if [ -z "$header" ]; then + echo ""; + fi; +} + +# Checks everything. +test_check_all() { + [ $# = 0 ] || abort "internal error"; + test_check_kind "Testing JVM backend" \ + "jvm" $FILES_RUN $FILES_JVM; + test_check_kind "Testing interpreter shell" \ + "shl" $FILES_SHL; + test_check_kind "Testing disassembler" \ + "dis" $FILES_DIS; + test_check_kind "Testing compiler (on files whose compilation should succeed)" \ + "pos" $FILES_POS; + test_check_kind "Testing compiler (on files whose compilation should fail)" \ + "neg" $FILES_NEG; + test_check_kind "Testing .NET backend" \ + "msil" $FILES_MSIL; + test_check_kind "Testing interpreter" \ + "int" $FILES_RUN $FILES_INT; +} + + +# 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;; + * ) + if [ ! -d "$1" ]; then + abort "don't know what to do with '$1'"; + fi;; + esac; + 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;; + 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";; + 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; + + NORUN="false"; + SHOWLOG="false"; + SHOWDIFF="false"; + FAILED="false"; + ERRORS=0; + SUCCESS_COUNT=0; + FAILURE_COUNT=0; + TESTROOT="/home/dragos/scala/test-nsc/files"; + SRCDIR="/home/dragos/scala/test-nsc/files"; + OBJDIR=""""; + + TEST_ALL="true"; + TEST_TYPE="auto"; + FILES_RUN=""; + FILES_JVM=""; + FILES_INT=""; + FILES_SHL=""; + FILES_DIS=""; + FILES_POS=""; + FILES_NEG=""; + FILES_MSIL=""; + + SCALA="$PREFIX/bin/scala"; + SOCOS="$PREFIX/bin/scalac"; + SURUS="$PREFIX/bin/scalarun"; + SCALAP="$PREFIX/bin/scalap"; + DIFF="diff"; + + case "$SCRIPT" in + scalanstest* ) + SOCOS="$PREFIX/bin/nsc"; + SCALA="$PREFIX/bin/ns"; + + ;; + esac; + + 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;; + --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| -? ) test_print_help; exit 0;; + --version ) test_print_version; exit 0;; + -* ) abort "unknown option $1";; + * ) test_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 | 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; + + SCALA_SCALA_ARGS="-Xmx512M $SCALA_SCALA_ARGS"; + export SCALA_SCALA_ARGS; + + if [ -n "$OBJDIR" ]; then + if [ -d "$OBJDIR" ] || mkdir -p "$OBJDIR"; then + OBJDIR=`cd "$OBJDIR"; pwd`; + else + abort "could not create directory '$OBJDIR'"; + fi + fi + + printf_outline "Source directory is: $SRCDIR\\n\\n"; + + 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="1.4.0.1"; +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 "$@";; + nsc ) scala_main "$@";; + scala-* ) scala_main "$@";; + scalac* ) compiler_start "" scala.tools.scalac.Main "$@";; +# scalansc* ) ncompiler_start "" scala.tools.nsc.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 "$@";; + scalatest* ) test_main "$@";; + scalanstest* ) test_main "$@";; + * ) abort "Don't know what to do for $SCRIPT.";; +esac; + +############################################################################## |