restored separate CLI parsing for bin/scala and bin/scalac ; refactor and cleanup

Author: philwalk

dist/bin/common

@@ -185,9 +185,9 @@ classpathArgs () {
   toolchain+="$JLINE_READER$PSEP"
   toolchain+="$JLINE_TERMINAL$PSEP"
   toolchain+="$JLINE_TERMINAL_JNA$PSEP"
-  toolchain+="$JNA$PSEP"
+  [ -n "${JNA-}" ] && toolchain+="$JNA$PSEP"
 
-  if [ -n "$jvm_cp_args" ]; then
+  if [ -n "${jvm_cp_args-}" ]; then
     jvm_cp_args="$toolchain$jvm_cp_args"
   else
     jvm_cp_args="$toolchain$PSEP"
@@ -201,6 +201,9 @@ DecompilerMain=dotty.tools.dotc.decompiler.Main
 ReplMain=dotty.tools.repl.Main
 ScriptingMain=dotty.tools.scripting.Main
 
+declare -a residual_args
+declare -a script_args
+
 addJava () {
   java_args+=("'$1'")
 }
@@ -210,44 +213,6 @@ addScala () {
 addResidual () {
   residual_args+=("'$1'")
 }
-addScripting () {
-  scripting_args+=("'$1'")
-}
-prepScalacCommandLine () {
-  withCompiler=true
-
-  while [[ $# -gt 0 ]]; do
-  case "$1" in
-             --) shift; for arg; do addResidual "$arg"; done; set -- ;;
-    -v|-verbose) verbose=true && addScala "-verbose" && shift ;;
-         -debug) DEBUG="$DEBUG_STR" && shift ;;
-      -q|-quiet) quiet=true && shift ;;
-
-      # Optimize for short-running applications, see https://github.com/lampepfl/dotty/issues/222
-      -Oshort) addJava "-XX:+TieredCompilation -XX:TieredStopAtLevel=1" && shift ;;
-          -repl) PROG_NAME="$ReplMain" && shift ;;
-        -script) PROG_NAME="$ScriptingMain" && target_script="$2" && shift && shift
-                 while [[ $# -gt 0 ]]; do addScripting "$1" && shift ; done ;;
-       -compile) PROG_NAME="$CompilerMain" && shift ;;
-     -decompile) PROG_NAME="$DecompilerMain" && shift ;;
-   -print-tasty) PROG_NAME="$DecompilerMain" && addScala "-print-tasty" && shift ;;
-           -run) PROG_NAME="$ReplMain" && shift ;;
-        -colors) colors=true && shift ;;
-     -no-colors) unset colors && shift ;;
-    -with-compiler) jvm_cp_args="$PSEP$DOTTY_COMP$PSEP$TASTY_CORE" && shift ;;
-
-            # break out -D and -J options and add them to java_args so
-            # they reach the JVM in time to do some good. The -D options
-            # will be available as system properties.
-            -D*) addJava "$1" && shift ;;
-            -J*) addJava "${1:2}" && shift ;;
-              *) addResidual "$1" && shift ;;
-    esac
-  done
-
-  classpathArgs
-
-  if [ "$PROG_NAME" == "$ScriptingMain" ]; then
-    scripting_string="-script $target_script ${scripting_args[@]}"
-  fi
+addScript () {
+  script_args+=("'$1'")
 }

dist/bin/scala

@@ -26,77 +26,81 @@ if [ -z "${PROG_HOME-}" ] ; then
   cd "$saveddir"
 fi
 
-addJava () {
-  java_args+=("'$1'")
-}
+source "$PROG_HOME/bin/common"
 
-addScalacOptions () {
-  java_options+=("'$1'")
+# This script operates in one of 3 usage modes:
+#   script
+#   repl
+#   run
+# execute_mode replaces mutually exclusive booleans:
+#  execute_repl=false
+#  execute_run=false
+#  execute_script=false
+setExecuteMode () {
+  case "${execute_mode-}" in
+  "") execute_mode="$1" ; shift ;;
+  *) echo "execute_mode==[${execute_mode-}], attempted overwrite by [$1]" 1>&2
+    exit 1
+    ;;
+  esac
 }
 
-source "$PROG_HOME/bin/common"
 
-declare -a residual_args
-declare -a script_args
-execute_repl=false
-execute_run=false
-execute_script=false
-with_compiler=false
-class_path_count=0
-CLASS_PATH=""
-save_compiled=false
+with_compiler=false             # to add compiler jars to repl classpath
+let class_path_count=0 || true  # count classpath args, warning if more than 1
+save_compiled=false             # to save compiled script jar in script directory
+CLASS_PATH="" || true           # scala classpath
 
 # Little hack to check if all arguments are options
 all_params="$*"
 truncated_params="${*#-}"
 # options_indicator != 0 if at least one parameter is not an option
 options_indicator=$(( ${#all_params} - ${#truncated_params} - $# ))
 
-[ -n "$SCALA_OPTS" ] && set -- $SCALA_OPTS "$@"
+[ -n "${SCALA_OPTS-}" ] && set -- $SCALA_OPTS "$@"
 
 while [[ $# -gt 0 ]]; do
   case "$1" in
     -repl)
-      execute_repl=true
+      setExecuteMode 'repl'
       shift
       ;;
     -run)
-      execute_run=true
+      setExecuteMode 'run'
       shift
       ;;
     -cp | -classpath)
       CLASS_PATH="$2${PSEP}"
-      class_path_count+=1
+      let class_path_count+=1
       shift
       shift
       ;;
-    -cp*|-classpath*)
+    -cp*|-classpath*) # partial fix for #10761
       # hashbang can combine args, e.g. "-classpath 'lib/*'"
       CLASS_PATH="${1#* *}${PSEP}"
-      class_path_count+=1
+      let class_path_count+=1
       shift
       ;;
     -with-compiler)
       with_compiler=true
       shift
       ;;
     @*|-color:*)
-      addScalacOptions "${1}"
+      addScala "${1}"
       shift
       ;;
     -save|-savecompiled)
       save_compiled=true
-      scala_script_options+=("$1")
+      addScala "$1"
       shift
       ;;
     -compile-only)
-      scala_script_options+=("$1")
+      addScala "$1"
       shift
       ;;
-    -d)
+    -d|-debug)
       DEBUG="$DEBUG_STR"
-      shift
-      ;;
+      shift ;;
     -version)
       # defer to scalac, then exit
       shift
@@ -106,17 +110,32 @@ while [[ $# -gt 0 ]]; do
       ;;
     -J*)
       addJava "${1:2}"
-      addScalacOptions "${1}"
+      addScala "${1}"
+      shift ;;
+    -v|-verbose)
+      verbose=true
+      addScala "-verbose"
       shift ;;
+    -run|-repl)
+      PROG_NAME="$ReplMain"
+      shift ;;
+
     *)
-      if [ $execute_script == false ]; then
+      if [ "${execute_mode-}" == 'script' ]; then
+        addScript "$1"
+      else
+        # script if extension .scala or .sc, or if has scala hashbang line
+
+        # no -f test, issue meaningful error message (file not found)
         if [[ "$1" == *.scala || "$1" == *.sc ]]; then
-          # is a script if extension .scala or .sc
-          # (even if file not found, to avoid adding likely typo to residual_args)
-          execute_script=true
-          target_script="$1"
+          setExecuteMode 'script' # execute_script=true
+
+        # -f test needed before we examine the hashbang line
         elif [[ (-f "$1" && `head -n 1 -- "$1" | grep '#!.*scala'`) ]]; then
-          execute_script=true
+          setExecuteMode 'script' # execute_script=true
+        fi
+
+        if [ "${execute_mode-}" == 'script' ]; then
           target_script="$1"
           if [ ! -f $target_script ]; then
             # likely a typo or missing script file, quit early
@@ -125,70 +144,93 @@ while [[ $# -gt 0 ]]; do
             onExit
           fi
         else
-          # unrecognized args appearing prior to a script name
-          residual_args+=("$1")
+          # all unrecognized args appearing prior to a script name
+          addResidual "$1"
         fi
-      else
-        script_args+=("$1")
       fi
       shift
       ;;
 
   esac
 done
 
+#[ -n "${dump_args}" ] && dumpArgs ; exit 2
+
+if [ -z "${execute_mode-}" ]; then
+  # no script was specified, set run or repl mode
+  if [[ $options_indicator -ne 0 || ${#residual_args[@]} -ne 0 ]]; then
+    setExecuteMode 'run'
+  else
+    setExecuteMode 'repl'
+  fi
+fi
+
 [ -n "${script_trace-}" ] && set -x
-if [ $execute_script == true ]; then
+
+case "${execute_mode-}" in
+script)
   if [ "$CLASS_PATH" ]; then
-    cp_arg="-classpath \"$CLASS_PATH\""
+    script_cp_arg="-classpath '$CLASS_PATH'"
   fi
-  java_options+=(${scala_script_options})
   setScriptName="-Dscript.path=$target_script"
   target_jar="${target_script%.*}.jar"
   if [[ $save_compiled == true && "$target_jar" -nt "$target_script" ]]; then
     eval "\"$JAVACMD\"" $setScriptName -jar "$target_jar" "${script_args[@]}"
     scala_exit_status=$?
   else
     [[ $save_compiled == true ]] && rm -f $target_jar
-    set -- ${cp_arg-} ${java_options[@]} ${residual_args[@]} -script "$target_script" ${script_args[@]}
-    PROG_MAIN=$ScriptingMain
-    prepScalacCommandLine "$@"
-    # exec here would prevent onExit from being called, leaving terminal in unusable state
+    PROG_NAME=$ScriptingMain
+    classpathArgs # initialize jvm_cp_args with toolchain classpath 
+    scripting_string="-script $target_script ${script_args[@]}"
+    # use eval instead of exec, to insure that onExit is subsequently called
+
+    # $script_cp_arg must be the first argument to $ScriptingMain
+    # $scripting_string  must be last
     eval "\"$JAVACMD\"" \
-         ${JAVA_OPTS:-$default_java_opts} \
-         "${DEBUG-}" \
-         "${java_args[@]}" \
-         "-classpath \"$jvm_cp_args\"" \
-         -Dscala.usejavacp=true \
-         "$PROG_NAME"  \
-         "${scala_args[@]}" \
-         "${residual_args[@]}" \
-         "${scripting_string-}"
+       ${JAVA_OPTS:-$default_java_opts} \
+       "${DEBUG-}" \
+       "${java_args[@]}" \
+       "-classpath \"$jvm_cp_args\"" \
+       -Dscala.usejavacp=true \
+       "$setScriptName" \
+       "$ScriptingMain"  \
+        ${script_cp_arg-} \
+       "${scala_args[@]}" \
+       "${residual_args[@]}" \
+       "${scripting_string-}"    # must be the last arguments
     scala_exit_status=$?
   fi
-elif [ $execute_repl == true ] || ([ $execute_run == false ] && [ $options_indicator == 0 ]); then
+  ;;
+
+repl)
   if [ "$CLASS_PATH" ]; then
-    cp_arg="-classpath \"$CLASS_PATH\""
+    repl_cparg="-classpath \"$CLASS_PATH\""
   fi
-  eval "\"$PROG_HOME/bin/scalac\" ${cp_arg-} ${java_options[@]} -repl ${residual_args[@]}"
+  eval "\"$PROG_HOME/bin/scalac\" ${repl_cparg-} ${scalac_options[@]} -repl ${residual_args[@]}"
   scala_exit_status=$?
-elif [ ${#residual_args[@]} -ne 0 ]; then
-  cp_arg="$DOTTY_LIB$PSEP$SCALA_LIB"
+  ;;
+
+run)
+  repl_cparg="$DOTTY_LIB$PSEP$SCALA_LIB"
   if [ -z "$CLASS_PATH" ]; then
-    cp_arg+="$PSEP."
+    repl_cparg+="$PSEP."
   else
-    cp_arg+="$PSEP$CLASS_PATH"
+    repl_cparg+="$PSEP$CLASS_PATH"
   fi
   if [ "$class_path_count" -gt 1 ]; then
     echo "warning: multiple classpaths are found, scala only use the last one."
   fi
   if [ $with_compiler == true ]; then
-    cp_arg+="$PSEP$DOTTY_COMP$PSEP$TASTY_CORE$PSEP$DOTTY_INTF$PSEP$SCALA_ASM$PSEP$DOTTY_STAGING$PSEP$DOTTY_TASTY_INSPECTOR"
+    repl_cparg+="$PSEP$DOTTY_COMP$PSEP$TASTY_CORE$PSEP$DOTTY_INTF$PSEP$SCALA_ASM$PSEP$DOTTY_STAGING$PSEP$DOTTY_TASTY_INSPECTOR"
   fi
   # exec here would prevent onExit from being called, leaving terminal in unusable state
-  eval "\"$JAVACMD\"" "$DEBUG"  "-classpath \"$cp_arg\"" "${java_args[@]}" "${residual_args[@]}"
+  eval "\"$JAVACMD\"" "$DEBUG"  "-classpath \"$repl_cparg\"" "${java_args[@]}" "${residual_args[@]}"
   scala_exit_status=$?
-else
+  ;;
+
+*)
   echo "warning: command option is not correct."
-fi
+  ;;
+esac
+
 onExit