From eed5ff3582546afc17f2f7ed0c5ec99a0f642c6d Mon Sep 17 00:00:00 2001 From: paltherr Date: Wed, 15 Sep 2004 16:03:54 +0000 Subject: - Changed scala_wrapper so that tools are run a... - Changed scala_wrapper so that tools are run as normal scala programs - Added support for SCALA_SOURCEPATH & SCALA_EXTDIRS Added properties - "scala.library.source.path" & "scala.library.class.path" Improved - computation of default bootclasspath Changed scalap to used ClassPath - from scala.tools.util --- sources/bin/.scala_wrapper.tmpl | 585 +++++++++++++++++++++------------------- 1 file changed, 308 insertions(+), 277 deletions(-) (limited to 'sources/bin') diff --git a/sources/bin/.scala_wrapper.tmpl b/sources/bin/.scala_wrapper.tmpl index 0769dda3a9..7bf24be40d 100644 --- a/sources/bin/.scala_wrapper.tmpl +++ b/sources/bin/.scala_wrapper.tmpl @@ -14,63 +14,71 @@ # Configuration # The configure function contains all the configurable variables of -# this script. The content of these variables may be overridden by -# defining an environment variable with the same name prefixed by -# SCALA_. For example, to run socos with a big initial heap size, one -# may run the command "env SCALA_JAVA_ARGS=-Xms1024m socos". +# 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_BOOTCLASSPATH: if defined, it is used as the default -# bootclasspath by the Scala compiler. # # - SCALA_CLASSPATH: if defined, it is used as the default classpath -# by the scala compiler. +# 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. # -# - CLASSPATH: if defined and if SCALA_CLASSPATH is undefined, it is -# used as the default classpath by the Scala compiler. +# - SCALA_EXTDIRS: if defined, it is used as the default extdirs by +# all Scala tools. # -# All paths and path lists must be in Unix form (i.e. use '/' as file -# separator and ':' as path separator). There is only one exception to -# this rule: CLASSPATH must be in Windows form (i.e. use '\' and ';') -# on Windows platforms. +# These variables must use the platform-specific form for paths and +# path lists. configure() { - # Location of the Scala library sources. These sources are - # included in the Scala distribution. - # This variable must refer a directory. - RUNTIME_SOURCES={#RUNTIME_SOURCES#}; + # Location of the Scala library sources. + default_LIBRARY_SOURCES={#LIBRARY_SOURCES#}; - # Location of the compiled Scala library. This library is included - # in the Scala distribution. - # This variable must refer a directory or a zip or jar file. - RUNTIME_CLASSES={#RUNTIME_CLASSES#}; + # Location of the Scala library. + default_LIBRARY_CLASSES={#LIBRARY_CLASSES#}; - # Location of the compiled Scala tools. These tools are included - # in the Scala distribution. - # This variable must refer a directory or a zip or jar file. - TOOLS_CLASSES={#TOOLS_CLASSES#}; + # Location of the Scala tools library. + default_TOOLS_CLASSES={#TOOLS_CLASSES#}; - # Location of the compiled fjbg library. This library is included - # in the Scala distribution. - # This variable must refer a directory or a zip or jar file. - FJBG_CLASSES={#FJBG_CLASSES#}; + # Location of the FJBG library. + default_FJBG_CLASSES={#FJBG_CLASSES#}; - # Location of the compiled msil library. This library is included - # in the Scala distribution. - # This variable must refer a directory or a zip or jar file. - MSIL_CLASSES={#MSIL_CLASSES#}; + # Location of the MSIL library. + default_MSIL_CLASSES={#MSIL_CLASSES#}; # Command to start the Java VM. - JAVA_EXEC="java"; + default_JAVA_CMD={#JAVA_CMD#}; # Additional arguments to pass to the Java VM. - JAVA_ARGS={#JAVA_ARGS#}; + 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. One may, for example, display the Java command that is - # started by "socos", by running "env SCALA_EXEC=echo socos". - EXEC="exec"; + # purposes. For example, one may display the Java command that is + # started by "scala", by running "env SCALA_EXEC=echo scala". + default_EXEC="exec"; } @@ -96,7 +104,7 @@ abort() { ############################################################################## # File name and path list conversion functions -# Prints the OS specific form of the given Unix form file name. +# Prints the OS-specific form of the specified Unix form file name. get_os_filename() { [ $# = 1 ] || abort "internal error"; case "$UNAME" in @@ -105,7 +113,7 @@ get_os_filename() { esac; } -# Prints the OS specific form of the given Unix form path list. +# Prints the Unix form of the specified OS-specific form file name. get_unix_filename() { [ $# = 1 ] || abort "internal error"; case "$UNAME" in @@ -114,7 +122,7 @@ get_unix_filename() { esac; } -# Prints the Unix form of the given OS specific form file name. +# Prints the OS-specific form of the specified Unix form path list. get_os_pathlist() { [ $# = 1 ] || abort "internal error"; case "$UNAME" in @@ -123,7 +131,7 @@ get_os_pathlist() { esac; } -# Prints the Unix form of the given OS specific form path list. +# Prints the Unix form of the specified OS-specific form path list. get_unix_pathlist() { [ $# = 1 ] || abort "internal error"; case "$UNAME" in @@ -133,330 +141,353 @@ get_unix_pathlist() { } ############################################################################## -# Variable configuration functions +# Path list construction functions -# Configures the variable with the given name. If a variable named -# SCALA_$1 is defined, assigns its value to the variable named $1, -# otherwise does nothing. -configure_variable() { - [ $# = 1 ] || abort "internal error"; +# Prints the concatenation of two path lists. +append_pathlists() { + [ $# = 2 ] || abort "internal error"; - if set | grep "^SCALA_$1=" > /dev/null; then - eval $1=\$SCALA_$1; + if [ -z "$1" ]; then + echo "$2"; + elif [ -z "$2" ]; then + echo "$1"; + else + echo "$1:$2"; fi; } -# Configures and tests the path variable with the given name. If a -# variable named SCALA_$1 is defined and refers an existing directory -# or file, assigns its value to the variable named $1. If, after that, -# the variable $1 refers a non-existing path, exits with an error. -configure_path_variable() { +############################################################################## +# 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"; - if set | grep "^SCALA_$1=" > /dev/null; then - path=`eval echo \\\$SCALA_\$1`; - if [ -f "$path" -o -d "$path" ]; then - eval $1=\$SCALA_$1; - else - warning "File refered by SCALA_$1 ($path) does not exist."; - unset SCALA_$1; - fi; - fi; + 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 + 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"; + ;; - path=`eval echo \\\$\$1`; - if [ ! -f "$path" -a ! -d "$path" ]; then - abort "File referred by $1 ($path) does not exist." \ - "Please, fix the definition of $1 in file $SOURCE." \ - "Alternatively you may also define the environment" \ - "variable SCALA_$1."; - fi + esac; } ############################################################################## -# Path list construction functions +# 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; +} -# Prepends a named path to a named path list. First, computes variable -# $2 and then updates the path list in variable $1 by appending the -# path from variable $2. -prepend_path() { - [ $# = 2 ] || abort "internal error"; +# 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; +} - compute_variable "$2"; +# 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; +} - if [ -z "`eval echo \\\$\$1`" ]; then - eval $1=\$$2; - else - eval $1=\$$2:\$$1; +# 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; } ############################################################################## -# Variable computation functions +# VM invocation functions -# Sets SCALA_CLASSPATH to its default value. -compute_default_scala_classpath() { - SCALA_CLASSPATH="."; +# Prints the VM script-suffix-specific arguments. +vm_get_script_suffix_args() { + case "$SCRIPT" in + *-debug* ) echo "-Djava.compiler=NONE -ea";; + esac; } -# Computes SCALA_CLASSPATH. -compute_scala_classpath() { - if [ -z "$SCALA_CLASSPATH" ]; then - if [ -n "$CLASSPATH" ]; then - SCALA_CLASSPATH=`get_unix_pathlist "$CLASSPATH"`; - else - compute_default_scala_classpath; - fi; - fi; -} +# Starts a Java VM with the specified arguments. +vm_start_java() { + # compute values + compute_value EXEC; + compute_value JAVA_CMD; + compute_value JAVA_ARGS; -# Sets SCALA_BOOTCLASSPATH to its default value. -compute_default_scala_bootclasspath() { - eval SCALA_BOOTCLASSPATH=""; - prepend_path SCALA_BOOTCLASSPATH RUNTIME_SOURCES; - prepend_path SCALA_BOOTCLASSPATH RUNTIME_CLASSES; + # 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; -# Computes SCALA_BOOTCLASSPATH. -compute_scala_bootclasspath() { - if [ -z "$SCALA_BOOTCLASSPATH" ]; then - compute_default_scala_bootclasspath; - fi; + # start Java VM + $current_EXEC $current_SCALA_CMD $current_SCALA_ARGS \ + `vm_get_script_suffix_args` "$@"; } -# Computes variable $1. -compute_variable() { - [ $# = 1 ] || abort "internal error"; +############################################################################## +# Scala invocation functions - case "$1" in - SCALA_CLASSPATH ) compute_scala_classpath;; - SCALA_BOOTCLASSPATH ) compute_scala_bootclasspath;; - RUNTIME_SOURCES ) configure_path_variable "$1";; - RUNTIME_CLASSES ) configure_path_variable "$1";; - TOOLS_CLASSES ) configure_path_variable "$1";; - FJBG_CLASSES ) configure_path_variable "$1";; - MSIL_CLASSES ) configure_path_variable "$1";; - JAVA_EXEC ) configure_variable "$1";; - JAVA_ARGS ) configure_variable "$1";; - EXEC ) configure_variable "$1";; - esac; +# 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 the command "scala". +scala() { + 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; } ############################################################################## -# Java invocation functions +# Tool invocation functions -# Starts a Java program with the given arguments and the following -# additional ones: -# - arguments specified by the variable JAVA_ARGS -# - script-suffix-specific arguments -exec_java() { - [ $# -gt 0 ] || abort "internal error"; +# 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; - # configure variables - compute_variable EXEC; - compute_variable JAVA_EXEC; - compute_variable JAVA_ARGS; + # compute value + compute_value LIBRARY_SOURCES; + compute_value LIBRARY_CLASSES; + compute_value TOOLS_CLASSES; - # append script-suffix-specific arguments - case "$SCRIPT" in - *-debug* ) JAVA_ARGS="$JAVA_ARGS -Djava.compiler=NONE -ea";; - esac; + # append tools library to classpath + classpath=`append_pathlists "$classpath" "$current_TOOLS_CLASSES"`; - # invoke Java - $EXEC $JAVA_EXEC $JAVA_ARGS "$@"; + # start Scala VM + tool_start0 -classpath "`get_os_pathlist "$classpath"`" "$@"; } -# Starts a Scala tool. The first argument must be either "java" or -# "scala". It tells whether the tool is written in Java or Scala. The -# following arguments are passed to exec_java. They must, at least, -# contain the name of the main class. -exec_tool() { - [ $# -gt 1 ] || abort "internal error"; - language="$1"; shift 1; - - # augment Java classpath - prepend_path JAVA_CLASSPATH TOOLS_CLASSES; - case "$language" in - java ) true;; - scala ) prepend_path JAVA_CLASSPATH RUNTIME_CLASSES;; - * ) abort "internal error: found language='$language'";; - esac; +tool_start0() { + if [ -n "`get_scala_extdirs`" ]; then + tool_start1 -Dscala.ext.dirs="`get_scala_extdirs`" "$@"; + else + tool_start1 "$@"; + fi; +} - # invoke Java - exec_java \ - -classpath "`get_os_pathlist "$JAVA_CLASSPATH"`" \ - -Dscala.home="$PREFIX" \ - -Dscala.product="$SCRIPT" \ - -Dscala.version="$VERSION" \ - "$@"; +tool_start1() { + if [ -n "`get_scala_bootclasspath`" ]; then + tool_start2 -Dscala.boot.class.path="`get_scala_bootclasspath`" "$@"; + else + tool_start2 "$@"; + fi; } -# Starts a Scala compile tool (one that uses properties -# scala.class.path and scala.boot.class.path). The first argument must -# be either "java" or "scala". It tells whether the tool is written in -# Java or Scala. The following arguments are passed to exec_java. They -# must, at least, contain the name of the main class. -exec_compile_tool() { - [ $# -gt 1 ] || abort "internal error"; - language="$1"; shift 1; +tool_start2() { + if [ -n "`get_scala_sourcepath`" ]; then + tool_start3 -Dscala.source.path="`get_scala_sourcepath`" "$@"; + else + tool_start3 "$@"; + fi; +} - # compute Scala classpath and bootclasspath - compute_scala_classpath; - compute_scala_bootclasspath; +tool_start3() { + if [ -n "`get_scala_classpath`" ]; then + tool_start4 -Dscala.class.path="`get_scala_classpath`" "$@"; + else + tool_start4 "$@"; + fi; +} - # invoke Java - exec_tool "$language" \ - -Dscala.class.path=`get_os_pathlist "$SCALA_CLASSPATH"` \ - -Dscala.boot.class.path=`get_os_pathlist "$SCALA_BOOTCLASSPATH"` \ +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"`" \ "$@"; } -# Starts a Scala compiler. The first argument must be either "java" or -# "scala". It tells whether the tool is written in Java or Scala. The -# following arguments are passed to exec_java. They must, at least, -# contain the name of the main class. -exec_compiler() { +############################################################################## +# 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"; - language="$1"; shift 1; + classpath="$1"; shift 1; - # augment Java classpath - prepend_path JAVA_CLASSPATH MSIL_CLASSES; - prepend_path JAVA_CLASSPATH FJBG_CLASSES; + # compute values + compute_value FJBG_CLASSES; + compute_value MSIL_CLASSES; - exec_compile_tool "$language" "$@"; + # 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. -scala_info_abort() { +info_abort() { error "$@"; - scala_info_print_usage 1>&2; + info_print_usage 1>&2; exit 1; } -# Prints value of $1. -scala_info_print_variable() { +# Prints value of variable $1. +info_print_variable() { [ $# = 1 ] || abort "internal error"; eval echo \"\$$1\"; } -# Prints default value of $1. -scala_info_print_variable_default() { +# Prints default value of value $1. +info_print_default_value() { [ $# = 1 ] || abort "internal error"; - case "$1" in - SCALA_CLASSPATH ) compute_default_scala_classpath;; - SCALA_BOOTCLASSPATH ) compute_default_scala_bootclasspath;; - esac; - scala_info_print_variable "$1"; + info_print_variable "default_$1"; } -# Prints current value of $1. -scala_info_print_variable_current() { +# Prints current value of value $1. +info_print_current_value() { [ $# = 1 ] || abort "internal error"; - compute_variable "$1"; - scala_info_print_variable "$1"; + compute_value "$1"; + info_print_variable "current_$1"; } # Implements "scala-info --home". -scala_info_option_home() { +info_option_home() { [ $# -gt 0 ] && abort "too many arguments"; echo "$PREFIX"; } # Implements "scala-info --version". -scala_info_option_version() { +info_option_version() { [ $# -gt 0 ] && abort "too many arguments"; echo "$VERSION"; } -# Implements "scala-info --$1 " -scala_info_option_x_variable() { - [ $# -lt 2 ] && abort "missing variable name"; +# Implements "scala-info --$1 " +info_option_x_value() { + [ $# -lt 2 ] && abort "missing value name"; [ $# -gt 2 ] && abort "too many arguments"; case "$2" in - CLASSPATH ) variable=SCALA_$2;; - BOOTCLASSPATH ) variable=SCALA_$2;; - RUNTIME_SOURCES ) variable=$2;; - RUNTIME_CLASSES ) variable=$2;; - TOOLS_CLASSES ) variable=$2;; - FJBG_CLASSES ) variable=$2;; - MSIL_CLASSES ) variable=$2;; - JAVA_EXEC ) variable=$2;; - JAVA_ARGS ) variable=$2;; - EXEC ) variable=$2;; - * ) abort "Unknown variable \`$2'";; + 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; - scala_info_print_variable_$1 $variable; + info_print_$1_value $value; } # Implements "scala-info --help". -scala_info_option_help() { +info_option_help() { echo "usage: $0