rdev/social_altruism
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Chat

Browse Source
This commit is contained in:
Jaime Freire
2023-12-22 09:03:25 +01:00
parent c18c4a2555
commit 3b223dfea2
109 changed files with 3661 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

605
sbt-dist/bin/sbt Executable file
View File

@ -0,0 +1,605 @@
#!/usr/bin/env bash
set +e
declare -a residual_args
declare -a java_args
declare -a scalac_args
declare -a sbt_commands
declare -a sbt_options
declare -a print_version
declare -a print_sbt_version
declare -a print_sbt_script_version
declare java_cmd=java
declare java_version
declare init_sbt_version=_to_be_replaced
declare sbt_default_mem=1024
declare -r default_sbt_opts=""
declare -r default_java_opts="-Dfile.encoding=UTF-8"
declare sbt_verbose=
declare sbt_debug=
### ------------------------------- ###
### Helper methods for BASH scripts ###
### ------------------------------- ###
# Bash reimplementation of realpath to return the absolute path
realpathish () {
(
TARGET_FILE="$1"
FIX_CYGPATH="$2"
cd "$(dirname "$TARGET_FILE")"
TARGET_FILE=$(basename "$TARGET_FILE")
COUNT=0
while [ -L "$TARGET_FILE" -a $COUNT -lt 100 ]
do
TARGET_FILE=$(readlink "$TARGET_FILE")
cd "$(dirname "$TARGET_FILE")"
TARGET_FILE=$(basename "$TARGET_FILE")
COUNT=$(($COUNT + 1))
done
# make sure we grab the actual windows path, instead of cygwin's path.
if [[ "x$FIX_CYGPATH" != "x" ]]; then
echo "$(cygwinpath "$(pwd -P)/$TARGET_FILE")"
else
echo "$(pwd -P)/$TARGET_FILE"
fi
)
}
# Uses uname to detect if we're in the odd cygwin environment.
is_cygwin() {
local os=$(uname -s)
case "$os" in
CYGWIN*) return 0 ;;
MINGW*) return 0 ;;
MSYS*) return 0 ;;
*) return 1 ;;
esac
}
# TODO - Use nicer bash-isms here.
CYGWIN_FLAG=$(if is_cygwin; then echo true; else echo false; fi)
# This can fix cygwin style /cygdrive paths so we get the
# windows style paths.
cygwinpath() {
local file="$1"
if [[ "$CYGWIN_FLAG" == "true" ]]; then #"
echo $(cygpath -w $file)
else
echo $file
fi
}
declare -r sbt_bin_dir="$(dirname "$(realpathish "$0")")"
declare -r sbt_home="$(dirname "$sbt_bin_dir")"
echoerr () {
echo 1>&2 "$@"
}
vlog () {
[[ $sbt_verbose || $sbt_debug ]] && echoerr "$@"
}
dlog () {
[[ $sbt_debug ]] && echoerr "$@"
}
jar_file () {
echo "$(cygwinpath "${sbt_home}/bin/sbt-launch.jar")"
}
acquire_sbt_jar () {
sbt_jar="$(jar_file)"
if [[ ! -f "$sbt_jar" ]]; then
echoerr "Could not find launcher jar: $sbt_jar"
exit 2
fi
}
rt_export_file () {
echo "${sbt_bin_dir}/java9-rt-export.jar"
}
# execRunner should be called only once to give up control to java
execRunner () {
# print the arguments one to a line, quoting any containing spaces
[[ $sbt_verbose || $sbt_debug ]] && echo "# Executing command line:" && {
for arg; do
if printf "%s\n" "$arg" | grep -q ' '; then
printf "\"%s\"\n" "$arg"
else
printf "%s\n" "$arg"
fi
done
echo ""
}
if [[ "$CYGWIN_FLAG" == "true" ]]; then
# In cygwin we loose the ability to re-hook stty if exec is used
# https://github.com/sbt/sbt-launcher-package/issues/53
"$@"
else
exec "$@"
fi
}
addJava () {
dlog "[addJava] arg = '$1'"
java_args=( "${java_args[@]}" "$1" )
}
addSbt () {
dlog "[addSbt] arg = '$1'"
sbt_commands=( "${sbt_commands[@]}" "$1" )
}
addResidual () {
dlog "[residual] arg = '$1'"
residual_args=( "${residual_args[@]}" "$1" )
}
addDebugger () {
addJava "-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=$1"
}
addMemory () {
dlog "[addMemory] arg = '$1'"
# evict memory related options
local xs=("${java_args[@]}")
java_args=()
for i in "${xs[@]}"; do
if ! [[ "${i}" == *-Xmx* ]] && ! [[ "${i}" == *-Xms* ]] && ! [[ "${i}" == *-XX:MaxPermSize* ]] && ! [[ "${i}" == *-XX:MaxMetaspaceSize* ]] && ! [[ "${i}" == *-XX:ReservedCodeCacheSize* ]]; then
java_args+=("${i}")
fi
done
local ys=("${sbt_options[@]}")
sbt_options=()
for i in "${ys[@]}"; do
if ! [[ "${i}" == *-Xmx* ]] && ! [[ "${i}" == *-Xms* ]] && ! [[ "${i}" == *-XX:MaxPermSize* ]] && ! [[ "${i}" == *-XX:MaxMetaspaceSize* ]] && ! [[ "${i}" == *-XX:ReservedCodeCacheSize* ]]; then
sbt_options+=("${i}")
fi
done
# a ham-fisted attempt to move some memory settings in concert
local mem=$1
local codecache=$(( $mem / 8 ))
(( $codecache > 128 )) || codecache=128
(( $codecache < 512 )) || codecache=512
local class_metadata_size=$(( $codecache * 2 ))
if [[ -z $java_version ]]; then
java_version=$(jdk_version)
fi
addJava "-Xms${mem}m"
addJava "-Xmx${mem}m"
addJava "-Xss4M"
addJava "-XX:ReservedCodeCacheSize=${codecache}m"
(( $java_version >= 8 )) || addJava "-XX:MaxPermSize=${class_metadata_size}m"
}
addDefaultMemory() {
# if we detect any of these settings in ${JAVA_OPTS} or ${JAVA_TOOL_OPTIONS} we need to NOT output our settings.
# The reason is the Xms/Xmx, if they don't line up, cause errors.
if [[ "${java_args[@]}" == *-Xmx* ]] || \
[[ "${java_args[@]}" == *-Xms* ]] || \
[[ "${java_args[@]}" == *-XX:+UseCGroupMemoryLimitForHeap* ]] || \
[[ "${java_args[@]}" == *-XX:MaxRAM* ]] || \
[[ "${java_args[@]}" == *-XX:InitialRAMPercentage* ]] || \
[[ "${java_args[@]}" == *-XX:MaxRAMPercentage* ]] || \
[[ "${java_args[@]}" == *-XX:MinRAMPercentage* ]]; then
:
elif [[ "${JAVA_TOOL_OPTIONS}" == *-Xmx* ]] || \
[[ "${JAVA_TOOL_OPTIONS}" == *-Xms* ]] || \
[[ "${JAVA_TOOL_OPTIONS}" == *-XX:+UseCGroupMemoryLimitForHeap* ]] || \
[[ "${JAVA_TOOL_OPTIONS}" == *-XX:MaxRAM* ]] || \
[[ "${JAVA_TOOL_OPTIONS}" == *-XX:InitialRAMPercentage* ]] || \
[[ "${JAVA_TOOL_OPTIONS}" == *-XX:MaxRAMPercentage* ]] || \
[[ "${JAVA_TOOL_OPTIONS}" == *-XX:MinRAMPercentage* ]] ; then
:
elif [[ "${sbt_options[@]}" == *-Xmx* ]] || \
[[ "${sbt_options[@]}" == *-Xms* ]] || \
[[ "${sbt_options[@]}" == *-XX:+UseCGroupMemoryLimitForHeap* ]] || \
[[ "${sbt_options[@]}" == *-XX:MaxRAM* ]] || \
[[ "${sbt_options[@]}" == *-XX:InitialRAMPercentage* ]] || \
[[ "${sbt_options[@]}" == *-XX:MaxRAMPercentage* ]] || \
[[ "${sbt_options[@]}" == *-XX:MinRAMPercentage* ]] ; then
:
else
addMemory $sbt_default_mem
fi
}
require_arg () {
local type="$1"
local opt="$2"
local arg="$3"
if [[ -z "$arg" ]] || [[ "${arg:0:1}" == "-" ]]; then
echo "$opt requires <$type> argument"
exit 1
fi
}
is_function_defined() {
declare -f "$1" > /dev/null
}
# parses JDK version from the -version output line.
# 8 for 1.8.0_nn, 9 for 9-ea etc, and "no_java" for undetected
jdk_version() {
local result
local lines=$("$java_cmd" -Xms32M -Xmx32M -version 2>&1 | tr '\r' '\n')
local IFS=$'\n'
for line in $lines; do
if [[ (-z $result) && ($line = *"version \""*) ]]
then
local ver=$(echo $line | sed -e 's/.*version "\(.*\)"\(.*\)/\1/; 1q')
# on macOS sed doesn't support '?'
if [[ $ver = "1."* ]]
then
result=$(echo $ver | sed -e 's/1\.\([0-9]*\)\(.*\)/\1/; 1q')
else
result=$(echo $ver | sed -e 's/\([0-9]*\)\(.*\)/\1/; 1q')
fi
fi
done
if [[ -z $result ]]
then
result=no_java
fi
echo "$result"
}
# Extracts the preloaded directory from either -Dsbt.preloaded or -Dsbt.global.base
# properties by looking at:
# - _JAVA_OPTIONS environment variable,
# - SBT_OPTS environment variable,
# - JAVA_OPTS environment variable and
# - properties set by command-line options
# in that order. The last one will be chosen such that `sbt.preloaded` is
# always preferred over `sbt.global.base`.
getPreloaded() {
local -a _java_options_array
local -a sbt_opts_array
local -a java_opts_array
read -a _java_options_array <<< "$_JAVA_OPTIONS"
read -a sbt_opts_array <<< "$SBT_OPTS"
read -a java_opts_array <<< "$JAVA_OPTS"
local args_to_check=(
"${_java_options_array[@]}"
"${sbt_opts_array[@]}"
"${java_opts_array[@]}"
"${java_args[@]}")
local via_global_base="$HOME/.sbt/preloaded"
local via_explicit=""
for opt in "${args_to_check[@]}"; do
if [[ "$opt" == -Dsbt.preloaded=* ]]; then
via_explicit="${opt#-Dsbt.preloaded=}"
elif [[ "$opt" == -Dsbt.global.base=* ]]; then
via_global_base="${opt#-Dsbt.global.base=}/preloaded"
fi
done
echo "${via_explicit:-${via_global_base}}"
}
syncPreloaded() {
local source_preloaded="$sbt_home/lib/local-preloaded/"
local target_preloaded="$(getPreloaded)"
if [[ "$init_sbt_version" == "" ]]; then
# FIXME: better $init_sbt_version detection
init_sbt_version="$(ls -1 "$source_preloaded/org/scala-sbt/sbt/")"
fi
[[ -f "$target_preloaded/org/scala-sbt/sbt/$init_sbt_version/" ]] || {
# lib/local-preloaded exists (This is optional)
[[ -d "$source_preloaded" ]] && {
command -v rsync >/dev/null 2>&1 && {
mkdir -p "$target_preloaded"
rsync --recursive --links --perms --times --ignore-existing "$source_preloaded" "$target_preloaded" || true
}
}
}
}
# Detect that we have java installed.
checkJava() {
local required_version="$1"
# Now check to see if it's a good enough version
local good_enough="$(expr $java_version ">=" $required_version)"
if [[ "$java_version" == "" ]]; then
echo
echo "No Java Development Kit (JDK) installation was detected."
echo Please go to http://www.oracle.com/technetwork/java/javase/downloads/ and download.
echo
exit 1
elif [[ "$good_enough" != "1" ]]; then
echo
echo "The Java Development Kit (JDK) installation you have is not up to date."
echo $script_name requires at least version $required_version+, you have
echo version $java_version
echo
echo Please go to http://www.oracle.com/technetwork/java/javase/downloads/ and download
echo a valid JDK and install before running $script_name.
echo
exit 1
fi
}
copyRt() {
local at_least_9="$(expr $java_version ">=" 9)"
if [[ "$at_least_9" == "1" ]]; then
rtexport=$(rt_export_file)
# The grep for java9-rt-ext- matches the filename prefix printed in Export.java
java9_ext=$("$java_cmd" "${sbt_options[@]}" "${java_args[@]}" \
-jar "$rtexport" --rt-ext-dir | grep java9-rt-ext-)
java9_rt=$(echo "$java9_ext/rt.jar")
vlog "[copyRt] java9_rt = '$java9_rt'"
if [[ ! -f "$java9_rt" ]]; then
echo copying runtime jar...
mkdir -p "$java9_ext"
"$java_cmd" \
"${sbt_options[@]}" \
"${java_args[@]}" \
-jar "$rtexport" \
"${java9_rt}"
fi
addJava "-Dscala.ext.dirs=${java9_ext}"
fi
}
run() {
java_args=($JAVA_OPTS)
sbt_options0=(${SBT_OPTS:-$default_sbt_opts})
# Split SBT_OPTS into options/commands
miniscript=$(map_args "${sbt_options0[@]}") && eval "${miniscript/options/sbt_options}" && \
eval "${miniscript/commands/sbt_additional_commands}"
# Combine command line options/commands and commands from SBT_OPTS
miniscript=$(map_args "$@") && eval "${miniscript/options/cli_options}" && eval "${miniscript/commands/cli_commands}"
args1=( "${cli_options[@]}" "${cli_commands[@]}" "${sbt_additional_commands[@]}" )
# process the combined args, then reset "$@" to the residuals
process_args "${args1[@]}"
vlog "[sbt_options] $(declare -p sbt_options)"
addDefaultMemory
set -- "${residual_args[@]}"
argumentCount=$#
# Copy preloaded repo to user's preloaded directory
syncPreloaded
# no jar? download it.
[[ -f "$sbt_jar" ]] || acquire_sbt_jar "$sbt_version" || {
# still no jar? uh-oh.
echo "Download failed. Obtain the sbt-launch.jar manually and place it at $sbt_jar"
exit 1
}
# TODO - java check should be configurable...
checkJava "6"
# Java 9 support
copyRt
# If we're in cygwin, we should use the windows config, and terminal hacks
if [[ "$CYGWIN_FLAG" == "true" ]]; then #"
stty -icanon min 1 -echo > /dev/null 2>&1
addJava "-Djline.terminal=jline.UnixTerminal"
addJava "-Dsbt.cygwin=true"
fi
if [[ $print_sbt_version ]]; then
execRunner "$java_cmd" -jar "$sbt_jar" "sbtVersion" | tail -1 | sed -e 's/\[info\]//g'
elif [[ $print_sbt_script_version ]]; then
echo "$init_sbt_version"
elif [[ $print_version ]]; then
execRunner "$java_cmd" -jar "$sbt_jar" "sbtVersion" | tail -1 | sed -e 's/\[info\]/sbt version in this project:/g'
echo "sbt script version: $init_sbt_version"
else
# run sbt
execRunner "$java_cmd" \
"${java_args[@]}" \
"${sbt_options[@]}" \
-jar "$sbt_jar" \
"${sbt_commands[@]}" \
"${residual_args[@]}"
fi
exit_code=$?
# Clean up the terminal from cygwin hacks.
if [[ "$CYGWIN_FLAG" == "true" ]]; then #"
stty icanon echo > /dev/null 2>&1
fi
exit $exit_code
}
declare -r noshare_opts="-Dsbt.global.base=project/.sbtboot -Dsbt.boot.directory=project/.boot -Dsbt.ivy.home=project/.ivy"
declare -r sbt_opts_file=".sbtopts"
declare -r etc_sbt_opts_file="/etc/sbt/sbtopts"
# this allows /etc/sbt/sbtopts location to be changed
declare -r etc_file="${SBT_ETC_FILE:-$etc_sbt_opts_file}"
declare -r dist_sbt_opts_file="${sbt_home}/conf/sbtopts"
declare -r win_sbt_opts_file="${sbt_home}/conf/sbtconfig.txt"
usage() {
cat <<EOM
Usage: `basename "$0"` [options]
-h | --help print this message
-v | --verbose this runner is chattier
-V | --version print sbt version information
--numeric-version print the numeric sbt version (sbt sbtVersion)
--script-version print the version of sbt script
-d | --debug set sbt log level to debug
-debug-inc | --debug-inc
enable extra debugging for the incremental debugger
--no-colors disable ANSI color codes
--color=auto|always|true|false|never
enable or disable ANSI color codes (sbt 1.3 and above)
--supershell=auto|always|true|false|never
enable or disable supershell (sbt 1.3 and above)
--traces generate Trace Event report on shutdown (sbt 1.3 and above)
--timings display task timings report on shutdown
--sbt-create start sbt even if current directory contains no sbt project
--sbt-dir <path> path to global settings/plugins directory (default: ~/.sbt)
--sbt-boot <path> path to shared boot directory (default: ~/.sbt/boot in 0.11 series)
--ivy <path> path to local Ivy repository (default: ~/.ivy2)
--mem <integer> set memory options (default: $sbt_default_mem)
--no-share use all local caches; no sharing
--no-global uses global caches, but does not use global ~/.sbt directory.
--jvm-debug <port> Turn on JVM debugging, open at the given port.
--batch disable interactive mode
# sbt version (default: from project/build.properties if present, else latest release)
--sbt-version <version> use the specified version of sbt
--sbt-jar <path> use the specified jar as the sbt launcher
# java version (default: java from PATH, currently $(java -version 2>&1 | grep version))
--java-home <path> alternate JAVA_HOME
# jvm options and output control
JAVA_OPTS environment variable, if unset uses "$default_java_opts"
.jvmopts if this file exists in the current directory, its contents
are appended to JAVA_OPTS
SBT_OPTS environment variable, if unset uses "$default_sbt_opts"
.sbtopts if this file exists in the current directory, its contents
are prepended to the runner args
/etc/sbt/sbtopts if this file exists, it is prepended to the runner args
-Dkey=val pass -Dkey=val directly to the java runtime
-J-X pass option -X directly to the java runtime
(-J is stripped)
-S-X add -X to sbt's scalacOptions (-S is stripped)
In the case of duplicated or conflicting options, the order above
shows precedence: JAVA_OPTS lowest, command line options highest.
EOM
}
process_my_args () {
while [[ $# -gt 0 ]]; do
case "$1" in
-batch|--batch) exec </dev/null && shift ;; #>
-sbt-create|--sbt-create) sbt_create=true && shift ;;
new) sbt_new=true && addResidual "$1" && shift ;;
*) addResidual "$1" && shift ;;
esac
done
# Now, ensure sbt version is used.
[[ "${sbt_version}XXX" != "XXX" ]] && addJava "-Dsbt.version=$sbt_version"
# Confirm a user's intent if the current directory does not look like an sbt
# top-level directory and neither the -sbt-create option nor the "new"
# command was given.
[[ -f ./build.sbt || -d ./project || -n "$sbt_create" || -n "$sbt_new" ]] || {
echo "[warn] Neither build.sbt nor a 'project' directory in the current directory: $(pwd)"
while true; do
echo 'c) continue'
echo 'q) quit'
read -p '? ' || exit 1
case "$REPLY" in
c|C) break ;;
q|Q) exit 1 ;;
esac
done
}
}
## map over argument array. this is used to process both command line arguments and SBT_OPTS
map_args () {
local options=()
local commands=()
while [[ $# -gt 0 ]]; do
case "$1" in
-no-colors|--no-colors) options=( "${options[@]}" "-Dsbt.log.noformat=true" ) && shift ;;
-timings|--timings) options=( "${options[@]}" "-Dsbt.task.timings=true" "-Dsbt.task.timings.on.shutdown=true" ) && shift ;;
-traces|--traces) options=( "${options[@]}" "-Dsbt.traces=true" ) && shift ;;
--supershell=*) options=( "${options[@]}" "-Dsbt.supershell=${1:13}" ) && shift ;;
-supershell=*) options=( "${options[@]}" "-Dsbt.supershell=${1:12}" ) && shift ;;
--color=*) options=( "${options[@]}" "-Dsbt.color=${1:8}" ) && shift ;;
-color=*) options=( "${options[@]}" "-Dsbt.color=${1:7}" ) && shift ;;
-no-share|--no-share) options=( "${options[@]}" "$noshare_opts" ) && shift ;;
-no-global|--no-global) options=( "${options[@]}" "-Dsbt.global.base=$(pwd)/project/.sbtboot" ) && shift ;;
-sbt-boot|--sbt-boot) require_arg path "$1" "$2" && options=( "${options[@]}" "-Dsbt.boot.directory=$2" ) && shift 2 ;;
-sbt-dir|--sbt-dir) require_arg path "$1" "$2" && options=( "${options[@]}" "-Dsbt.global.base=$2" ) && shift 2 ;;
-debug|--debug) commands=( "${commands[@]}" "-debug" ) && shift ;;
-debug-inc|--debug-inc) options=( "${options[@]}" "-Dxsbt.inc.debug=true" ) && shift ;;
*) options=( "${options[@]}" "$1" ) && shift ;;
esac
done
declare -p options
declare -p commands
}
process_args () {
while [[ $# -gt 0 ]]; do
case "$1" in
-h|-help|--help) usage; exit 1 ;;
-v|-verbose|--verbose) sbt_verbose=1 && shift ;;
-V|-version|--version) print_version=1 && shift ;;
--numeric-version) print_sbt_version=1 && shift ;;
--script-version) print_sbt_script_version=1 && shift ;;
-d|-debug|--debug) sbt_debug=1 && addSbt "-debug" && shift ;;
-ivy|--ivy) require_arg path "$1" "$2" && addJava "-Dsbt.ivy.home=$2" && shift 2 ;;
-mem|--mem) require_arg integer "$1" "$2" && addMemory "$2" && shift 2 ;;
-jvm-debug|--jvm-debug) require_arg port "$1" "$2" && addDebugger $2 && shift 2 ;;
-batch|--batch) exec </dev/null && shift ;;
-sbt-jar|--sbt-jar) require_arg path "$1" "$2" && sbt_jar="$2" && shift 2 ;;
-sbt-version|--sbt-version) require_arg version "$1" "$2" && sbt_version="$2" && shift 2 ;;
-java-home|--java-home) require_arg path "$1" "$2" &&
java_cmd="$2/bin/java" &&
export JAVA_HOME="$2" &&
export JDK_HOME="$2" &&
export PATH="$2/bin:$PATH" &&
shift 2 ;;
"-D*"|-D*) addJava "$1" && shift ;;
-J*) addJava "${1:2}" && shift ;;
*) addResidual "$1" && shift ;;
esac
done
is_function_defined process_my_args && {
myargs=("${residual_args[@]}")
residual_args=()
process_my_args "${myargs[@]}"
}
java_version="$(jdk_version)"
vlog "[process_args] java_version = '$java_version'"
}
loadConfigFile() {
# Make sure the last line is read even if it doesn't have a terminating \n
cat "$1" | sed $'/^\#/d;s/\r$//' | while read -r line || [[ -n "$line" ]]; do
eval echo $line
done
}
# Here we pull in the default settings configuration.
[[ -f "$dist_sbt_opts_file" ]] && set -- $(loadConfigFile "$dist_sbt_opts_file") "$@"
# Here we pull in the global settings configuration.
[[ -f "$etc_file" ]] && set -- $(loadConfigFile "$etc_file") "$@"
# Pull in the project-level config file, if it exists.
[[ -f "$sbt_opts_file" ]] && set -- $(loadConfigFile "$sbt_opts_file") "$@"
# Pull in the project-level java config, if it exists.
[[ -f ".jvmopts" ]] && export JAVA_OPTS="$JAVA_OPTS $(loadConfigFile .jvmopts)"
# Pull in default JAVA_OPTS
[[ -z "${JAVA_OPTS// }" ]] && export JAVA_OPTS="$default_java_opts"
run "$@"

BIN
sbt-dist/bin/sbt-launch.jar Normal file
View File

Binary file not shown.

902
sbt-dist/bin/sbt.bat Normal file
View File

@ -0,0 +1,902 @@
@REM SBT launcher script
@REM
@REM Environment:
@REM JAVA_HOME - location of a JDK home dir (mandatory)
@REM SBT_OPTS - JVM options (optional)
@REM Configuration:
@REM sbtconfig.txt found in the SBT_HOME.
@REM ZOMG! We need delayed expansion to build up CFG_OPTS later
@setlocal enabledelayedexpansion
@echo off
set SBT_BIN_DIR=%~dp0
if not defined SBT_HOME for %%I in ("!SBT_BIN_DIR!\..") do set "SBT_HOME=%%~fI"
set SBT_ARGS=
set _JAVACMD=
set _SBT_OPTS=
set _JAVA_OPTS=
set init_sbt_version=_to_be_replaced
set sbt_default_mem=1024
set default_sbt_opts=
set default_java_opts=-Dfile.encoding=UTF-8
set sbt_jar=
set sbt_args_print_version=
set sbt_args_print_sbt_version=
set sbt_args_print_sbt_script_version=
set sbt_args_verbose=
set sbt_args_debug=
set sbt_args_debug_inc=
set sbt_args_batch=
set sbt_args_color=
set sbt_args_no_colors=
set sbt_args_no_global=
set sbt_args_no_share=
set sbt_args_sbt_jar=
set sbt_args_ivy=
set sbt_args_supershell=
set sbt_args_timings=
set sbt_args_traces=
set sbt_args_sbt_create=
set sbt_args_sbt_dir=
set sbt_args_sbt_version=
set sbt_args_mem=
rem users can set SBT_OPTS via .sbtopts
if exist .sbtopts for /F %%A in (.sbtopts) do (
set _sbtopts_line=%%A
if not "!_sbtopts_line:~0,1!" == "#" (
if defined _SBT_OPTS (
set _SBT_OPTS=!_SBT_OPTS! %%A
) else (
set _SBT_OPTS=%%A
)
)
)
rem TODO: remove/deprecate sbtconfig.txt and parse the sbtopts files
rem FIRST we load the config file of extra options.
set SBT_CONFIG=!SBT_HOME!\conf\sbtconfig.txt
set SBT_CFG_OPTS=
for /F "tokens=* eol=# usebackq delims=" %%i in ("!SBT_CONFIG!") do (
set DO_NOT_REUSE_ME=%%i
rem ZOMG (Part #2) WE use !! here to delay the expansion of
rem SBT_CFG_OPTS, otherwise it remains "" for this loop.
set SBT_CFG_OPTS=!SBT_CFG_OPTS! !DO_NOT_REUSE_ME!
)
rem poor man's jenv (which is not available on Windows)
if defined JAVA_HOMES (
if exist .java-version for /F %%A in (.java-version) do (
set JAVA_HOME=%JAVA_HOMES%\%%A
set JDK_HOME=%JAVA_HOMES%\%%A
)
)
rem must set PATH or wrong javac is used for java projects
if defined JAVA_HOME set "PATH=%JAVA_HOME%\bin;%PATH%"
rem We use the value of the JAVACMD environment variable if defined
if defined JAVACMD set "_JAVACMD=%JAVACMD%"
rem remove quotes
if defined _JAVACMD set _JAVACMD=!_JAVACMD:"=!
if not defined _JAVACMD (
if not "%JAVA_HOME%" == "" (
if exist "%JAVA_HOME%\bin\java.exe" set "_JAVACMD=%JAVA_HOME%\bin\java.exe"
)
)
if not defined _JAVACMD set _JAVACMD=java
rem users can set JAVA_OPTS via .jvmopts (sbt-extras style)
if exist .jvmopts for /F %%A in (.jvmopts) do (
set _jvmopts_line=%%A
if not "!_jvmopts_line:~0,1!" == "#" (
if defined _JAVA_OPTS (
set _JAVA_OPTS=!_JAVA_OPTS! %%A
) else (
set _JAVA_OPTS=%%A
)
)
)
rem We use the value of the JAVA_OPTS environment variable if defined, rather than the config.
if not defined _JAVA_OPTS if defined JAVA_OPTS set _JAVA_OPTS=%JAVA_OPTS%
if not defined _JAVA_OPTS if defined default_java_opts set _JAVA_OPTS=!default_java_opts!
rem We use the value of the SBT_OPTS environment variable if defined, rather than the config.
if not defined _SBT_OPTS if defined SBT_OPTS set _SBT_OPTS=%SBT_OPTS%
if not defined _SBT_OPTS if defined SBT_CFG_OPTS set _SBT_OPTS=!SBT_CFG_OPTS!
if not defined _SBT_OPTS if defined default_sbt_opts set _SBT_OPTS=!default_sbt_opts!
:args_loop
shift
if "%~0" == "" goto args_end
set g=%~0
rem make sure the sbt_args_debug gets set first incase any argument parsing uses :dlog
if "%~0" == "-d" set _debug_arg=true
if "%~0" == "--debug" set _debug_arg=true
if defined _debug_arg (
set _debug_arg=
set sbt_args_debug=1
set SBT_ARGS=-debug !SBT_ARGS!
goto args_loop
)
if "%~0" == "-h" goto usage
if "%~0" == "-help" goto usage
if "%~0" == "--help" goto usage
if "%~0" == "-v" set _verbose_arg=true
if "%~0" == "-verbose" set _verbose_arg=true
if "%~0" == "--verbose" set _verbose_arg=true
if defined _verbose_arg (
set _verbose_arg=
set sbt_args_verbose=1
goto args_loop
)
if "%~0" == "-V" set _version_arg=true
if "%~0" == "-version" set _version_arg=true
if "%~0" == "--version" set _version_arg=true
if defined _version_arg (
set _version_arg=
set sbt_args_print_version=1
goto args_loop
)
if "%~0" == "-batch" set _batch_arg=true
if "%~0" == "--batch" set _batch_arg=true
if defined _batch_arg (
set _batch_arg=
set sbt_args_batch=1
goto args_loop
)
if "%~0" == "-no-colors" set _no_colors_arg=true
if "%~0" == "--no-colors" set _no_colors_arg=true
if defined _no_colors_arg (
set _no_colors_arg=
set sbt_args_no_colors=1
goto args_loop
)
if "%~0" == "-no-global" set _no_global_arg=true
if "%~0" == "--no-global" set _no_global_arg=true
if defined _no_global_arg (
set _no_global_arg=
set sbt_args_no_global=1
goto args_loop
)
if "%~0" == "-traces" set _traces_arg=true
if "%~0" == "--traces" set _traces_arg=true
if defined _traces_arg (
set _traces_arg=
set sbt_args_traces=1
goto args_loop
)
if "%~0" == "-sbt-create" set _sbt_create_arg=true
if "%~0" == "--sbt-create" set _sbt_create_arg=true
if defined _sbt_create_arg (
set _sbt_create_arg=
set sbt_args_sbt_create=1
goto args_loop
)
if "%~0" == "-sbt-dir" set _sbt_dir_arg=true
if "%~0" == "--sbt-dir" set _sbt_dir_arg=true
if defined _sbt_dir_arg (
set _sbt_dir_arg=
if not "%~1" == "" (
set sbt_args_sbt_dir=%1
shift
goto args_loop
) else (
echo "%~0" is missing a value
goto error
)
)
if "%~0" == "-sbt-boot" set _sbt_boot_arg=true
if "%~0" == "--sbt-boot" set _sbt_boot_arg=true
if defined _sbt_boot_arg (
set _sbt_boot_arg=
if not "%~1" == "" (
set sbt_args_sbt_boot=%1
shift
goto args_loop
) else (
echo "%~0" is missing a value
goto error
)
)
if "%~0" == "-sbt-jar" set _sbt_jar=true
if "%~0" == "--sbt-jar" set _sbt_jar=true
if defined _sbt_jar (
set _sbt_jar=
if not "%~1" == "" (
if exist "%~1" (
set sbt_args_sbt_jar=%1
shift
goto args_loop
) else (
echo %~1 does not exist
goto error
)
) else (
echo "%~0" is missing a value
goto error
)
)
if "%~0" == "-ivy" set _sbt_ivy_arg=true
if "%~0" == "--ivy" set _sbt_ivy_arg=true
if defined _sbt_ivy_arg (
set _sbt_ivy_arg=
if not "%~1" == "" (
set sbt_args_ivy=%1
shift
goto args_loop
) else (
echo "%~0" is missing a value
goto error
)
)
if "%~0" == "-debug-inc" set _debug_inc_arg=true
if "%~0" == "--debug-inc" set _debug_inc_arg=true
if defined _debug_inc_arg (
set _debug_inc_arg=
set sbt_args_debug_inc=1
goto args_loop
)
if "%~0" == "--sbt-version" set _sbt_version_arg=true
if "%~0" == "-sbt-version" set _sbt_version_arg=true
if defined _sbt_version_arg (
set _sbt_version_arg=
if not "%~1" == "" (
set sbt_args_sbt_version=%~1
shift
goto args_loop
) else (
echo "%~0" is missing a value
goto error
)
)
if "%~0" == "--mem" set _sbt_mem_arg=true
if "%~0" == "-mem" set _sbt_mem_arg=true
if defined _sbt_mem_arg (
set _sbt_mem_arg=
if not "%~1" == "" (
set sbt_args_mem=%~1
shift
goto args_loop
) else (
echo "%~0" is missing a value
goto error
)
)
if "%~0" == "--supershell" set _supershell_arg=true
if "%~0" == "-supershell" set _supershell_arg=true
if defined _supershell_arg (
set _supershell_arg=
if not "%~1" == "" (
set sbt_args_supershell=%~1
shift
goto args_loop
) else (
echo "%~0" is missing a value
goto error
)
)
if "%~0" == "--color" set _color_arg=true
if "%~0" == "-color" set _color_arg=true
if defined _color_arg (
set _color_arg=
if not "%~1" == "" (
set sbt_args_color=%~1
shift
goto args_loop
) else (
echo "%~0" is missing a value
goto error
)
goto args_loop
)
if "%~0" == "--no-share" set _no_share_arg=true
if "%~0" == "-no-share" set _no_share_arg=true
if defined _no_share_arg (
set _no_share_arg=
set sbt_args_no_share=1
goto args_loop
)
if "%~0" == "--timings" set _timings_arg=true
if "%~0" == "-timings" set _timings_arg=true
if defined _timings_arg (
set _timings_arg=
set sbt_args_timings=1
goto args_loop
)
if "%~0" == "--script-version" (
set sbt_args_print_sbt_script_version=1
goto args_loop
)
if "%~0" == "--numeric-version" (
set sbt_args_print_sbt_version=1
goto args_loop
)
if "%~0" == "-jvm-debug" set _jvm_debug_arg=true
if "%~0" == "--jvm-debug" set _jvm_debug_arg=true
if defined _jvm_debug_arg (
set _jvm_debug_arg=
if not "%~1" == "" (
set /a JVM_DEBUG_PORT=%~1 2>nul >nul
if !JVM_DEBUG_PORT! EQU 0 (
rem next argument wasn't a port, set a default and process next arg
set /A JVM_DEBUG_PORT=5005
goto args_loop
) else (
shift
goto args_loop
)
)
)
if "%~0" == "-java-home" set _java_home_arg=true
if "%~0" == "--java-home" set _java_home_arg=true
if defined _java_home_arg (
set _java_home_arg=
if not "%~1" == "" (
if exist "%~1\bin\java.exe" (
set "_JAVACMD=%~1\bin\java.exe"
set "JAVA_HOME=%~1"
set "JDK_HOME=%~1"
shift
goto args_loop
) else (
echo Directory "%~1" for JAVA_HOME is not valid
goto error
)
) else (
echo Second argument for --java-home missing
goto error
)
)
if "%~0" == "new" (
if not defined SBT_ARGS (
set sbt_new=true
)
)
if "%g:~0,2%" == "-D" (
rem special handling for -D since '=' gets parsed away
for /F "tokens=1 delims==" %%a in ("%g%") do (
rem make sure it doesn't have the '=' already
if "%g%" == "%%a" (
if not "%~1" == "" (
call :dlog [args_loop] -D argument %~0=%~1
set "SBT_ARGS=!SBT_ARGS! %~0=%~1"
shift
goto args_loop
) else (
echo %g% is missing a value
goto error
)
) else (
call :dlog [args_loop] -D argument %~0
set "SBT_ARGS=!SBT_ARGS! %~0"
goto args_loop
)
)
)
if not "%g:~0,5%" == "-XX:+" if not "%g:~0,5%" == "-XX:-" if "%g:~0,3%" == "-XX" (
rem special handling for -XX since '=' gets parsed away
for /F "tokens=1 delims==" %%a in ("%g%") do (
rem make sure it doesn't have the '=' already
if "%g%" == "%%a" (
if not "%~1" == "" (
call :dlog [args_loop] -XX argument %~0=%~1
set "SBT_ARGS=!SBT_ARGS! %~0=%~1"
shift
goto args_loop
) else (
echo %g% is missing a value
goto error
)
) else (
call :dlog [args_loop] -XX argument %~0
set "SBT_ARGS=!SBT_ARGS! %~0"
goto args_loop
)
)
)
rem the %0 (instead of %~0) preserves original argument quoting
set SBT_ARGS=!SBT_ARGS! %0
goto args_loop
:args_end
rem Confirm a user's intent if the current directory does not look like an sbt
rem top-level directory and the "new" command was not given.
if not defined sbt_args_sbt_create if not defined sbt_args_print_version if not defined sbt_args_print_sbt_version if not defined sbt_args_print_sbt_script_version if not exist build.sbt (
if not exist project\ (
if not defined sbt_new (
echo [warn] Neither build.sbt nor a 'project' directory in the current directory: "%CD%"
setlocal
:confirm
echo c^) continue
echo q^) quit
set /P reply=^?
if /I "!reply!" == "c" (
goto confirm_end
) else if /I "!reply!" == "q" (
exit /B 1
)
goto confirm
:confirm_end
endlocal
)
)
)
call :process
rem avoid bootstrapping/java version check for script version
if !sbt_args_print_sbt_script_version! equ 1 (
echo !init_sbt_version!
goto :eof
)
call :checkjava
call :copyrt
if defined JVM_DEBUG_PORT (
set _JAVA_OPTS=!_JAVA_OPTS! -agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=!JVM_DEBUG_PORT!
)
call :sync_preloaded
call :run !SBT_ARGS!
if ERRORLEVEL 1 goto error
goto end
:run
rem set arguments
if defined sbt_args_debug_inc (
set _SBT_OPTS=-Dxsbt.inc.debug=true !_SBT_OPTS!
)
if defined sbt_args_no_colors (
set _SBT_OPTS=-Dsbt.log.noformat=true !_SBT_OPTS!
)
if defined sbt_args_no_global (
set _SBT_OPTS=-Dsbt.global.base=project/.sbtboot !_SBT_OPTS!
)
if defined sbt_args_no_share (
set _SBT_OPTS=-Dsbt.global.base=project/.sbtboot -Dsbt.boot.directory=project/.boot -Dsbt.ivy.home=project/.ivy !_SBT_OPTS!
)
if defined sbt_args_supershell (
set _SBT_OPTS=-Dsbt.supershell=!sbt_args_supershell! !_SBT_OPTS!
)
if defined sbt_args_sbt_version (
set _SBT_OPTS=-Dsbt.version=!sbt_args_sbt_version! !_SBT_OPTS!
)
if defined sbt_args_sbt_dir (
set _SBT_OPTS=-Dsbt.global.base=!sbt_args_sbt_dir! !_SBT_OPTS!
)
if defined sbt_args_sbt_boot (
set _SBT_OPTS=-Dsbt.boot.directory=!sbt_args_sbt_boot! !_SBT_OPTS!
)
if defined sbt_args_ivy (
set _SBT_OPTS=-Dsbt.ivy.home=!sbt_args_ivy! !_SBT_OPTS!
)
if defined sbt_args_color (
set _SBT_OPTS=-Dsbt.color=!sbt_args_color! !_SBT_OPTS!
)
if defined sbt_args_mem (
call :addMemory !sbt_args_mem!
) else (
call :addDefaultMemory
)
if defined sbt_args_timings (
set _SBT_OPTS=-Dsbt.task.timings=true -Dsbt.task.timings.on.shutdown=true !_SBT_OPTS!
)
if defined sbt_args_traces (
set _SBT_OPTS=-Dsbt.traces=true !_SBT_OPTS!
)
if defined sbt_args_sbt_jar (
set "sbt_jar=!sbt_args_sbt_jar!"
) else (
set "sbt_jar=!SBT_HOME!\bin\sbt-launch.jar"
)
set sbt_jar=!sbt_jar:"=!
rem TODO: _SBT_OPTS needs to be processed as args and diffed against SBT_ARGS
if !sbt_args_print_sbt_version! equ 1 (
call :set_sbt_version
echo !sbt_version!
goto :eof
)
if !sbt_args_print_version! equ 1 (
call :set_sbt_version
echo sbt version in this project: !sbt_version!
echo sbt script version: !init_sbt_version!
goto :eof
)
if defined sbt_args_verbose (
echo # Executing command line:
echo "!_JAVACMD!"
if defined _JAVA_OPTS ( call :echolist !_JAVA_OPTS! )
if defined _SBT_OPTS ( call :echolist !_SBT_OPTS! )
echo -cp
echo "!sbt_jar!"
echo xsbt.boot.Boot
if not "%~1" == "" ( call :echolist %* )
echo.
)
"!_JAVACMD!" !_JAVA_OPTS! !_SBT_OPTS! -cp "!sbt_jar!" xsbt.boot.Boot %*
goto :eof
rem for expression tries to interpret files, so simply loop over %* instead
rem fixes dealing with quotes after = args: -Dscala.ext.dirs="C:\Users\First Last\.sbt\0.13\java9-rt-ext-adoptopenjdk_11_0_3"
:echolist
rem call method is in first call of %0
shift
if "%~0" == "" goto echolist_end
set "p=%~0"
if "%p:~0,2%" == "-D" (
rem special handling for -D since '=' gets parsed away
for /F "tokens=1 delims==" %%a in ("%p%") do (
rem make sure it doesn't have the '=' already
if "%p%" == "%%a" if not "%~1" == "" (
echo %0=%1
shift
goto echolist
)
)
)
if not "%p:~0,5%" == "-XX:+" if not "%p:~0,5%" == "-XX:-" if "%p:~0,3%" == "-XX" (
rem special handling for -XX since '=' gets parsed away
for /F "tokens=1 delims==" %%a in ("%p%") do (
rem make sure it doesn't have the '=' already
if "%p%" == "%%a" if not "%~1" == "" (
echo %0=%1
shift
goto echolist
)
)
)
if "%p:~0,14%" == "-agentlib:jdwp" (
rem special handling for --jvm-debug since '=' and ',' gets parsed away
for /F "tokens=1 delims==" %%a in ("%p%") do (
rem make sure it doesn't have the '=' already
if "%p%" == "%%a" if not "%~1" == "" if not "%~2" == "" if not "%~3" == "" if not "%~4" == "" if not "%~5" == "" if not "%~6" == "" if not "%~7" == "" if not "%~8" == "" (
echo %0=%1=%2,%3=%4,%5=%6,%7=%8
shift & shift & shift & shift & shift & shift & shift & shift
goto echolist
)
)
)
echo %0
goto echolist
:echolist_end
exit /B 0
:addJava
call :dlog [addJava] arg = '%*'
set "_JAVA_OPTS=!_JAVA_OPTS! %*"
exit /B 0
:addMemory
call :dlog [addMemory] arg = '%*'
rem evict memory related options
set _new_java_opts=
set _old_java_opts=!_JAVA_OPTS!
:next_java_opt
if "!_old_java_opts!" == "" goto :done_java_opt
for /F "tokens=1,*" %%g in ("!_old_java_opts!") do (
set "p=%%g"
if not "!p:~0,4!" == "-Xmx" if not "!p:~0,4!" == "-Xms" if not "!p:~0,15!" == "-XX:MaxPermSize" if not "!p:~0,20!" == "-XX:MaxMetaspaceSize" if not "!p:~0,25!" == "-XX:ReservedCodeCacheSize" (
set _new_java_opts=!_new_java_opts! %%g
)
set "_old_java_opts=%%h"
)
goto :next_java_opt
:done_java_opt
set _JAVA_OPTS=!_new_java_opts!
set _new_sbt_opts=
set _old_sbt_opts=!_SBT_OPTS!
:next_sbt_opt
if "!_old_sbt_opts!" == "" goto :done_sbt_opt
for /F "tokens=1,*" %%g in ("!_old_sbt_opts!") do (
set "p=%%g"
if not "!p:~0,4!" == "-Xmx" if not "!p:~0,4!" == "-Xms" if not "!p:~0,15!" == "-XX:MaxPermSize" if not "!p:~0,20!" == "-XX:MaxMetaspaceSize" if not "!p:~0,25!" == "-XX:ReservedCodeCacheSize" (
set _new_sbt_opts=!_new_sbt_opts! %%g
)
set "_old_sbt_opts=%%h"
)
goto :next_sbt_opt
:done_sbt_opt
set _SBT_OPTS=!_new_sbt_opts!
rem a ham-fisted attempt to move some memory settings in concert
set mem=%1
set /a codecache=!mem! / 8
if !codecache! GEQ 512 set /a codecache=512
if !codecache! LEQ 128 set /a codecache=128
set /a class_metadata_size=!codecache! * 2
call :addJava -Xms!mem!m
call :addJava -Xmx!mem!m
call :addJava -Xss4M
call :addJava -XX:ReservedCodeCacheSize=!codecache!m
if /I !JAVA_VERSION! LSS 8 (
call :addJava -XX:MaxPermSize=!class_metadata_size!m
)
exit /B 0
:addDefaultMemory
rem if we detect any of these settings in ${JAVA_OPTS} or ${JAVA_TOOL_OPTIONS} we need to NOT output our settings.
rem The reason is the Xms/Xmx, if they don't line up, cause errors.
set _has_memory_args=
if defined _JAVA_OPTS for /F %%g in ("!_JAVA_OPTS!") do (
set "p=%%g"
if "!p:~0,4!" == "-Xmx" set _has_memory_args=1
if "!p:~0,4!" == "-Xms" set _has_memory_args=1
)
if defined JAVA_TOOL_OPTIONS for /F %%g in ("%JAVA_TOOL_OPTIONS%") do (
set "p=%%g"
if "!p:~0,4!" == "-Xmx" set _has_memory_args=1
if "!p:~0,4!" == "-Xms" set _has_memory_args=1
)
if defined _SBT_OPTS for /F %%g in ("!_SBT_OPTS!") do (
set "p=%%g"
if "!p:~0,4!" == "-Xmx" set _has_memory_args=1
if "!p:~0,4!" == "-Xms" set _has_memory_args=1
)
if not defined _has_memory_args (
call :addMemory !sbt_default_mem!
)
exit /B 0
:dlog
if defined sbt_args_debug (
echo %* 1>&2
)
exit /B 0
:process
rem Parses x out of 1.x; for example 8 out of java version 1.8.0_xx
rem Otherwise, parses the major version; 9 out of java version 9-ea
set JAVA_VERSION=0
for /f "tokens=3 usebackq" %%g in (`CALL "!_JAVACMD!" -Xms32M -Xmx32M -version 2^>^&1 ^| findstr /i version`) do (
set JAVA_VERSION=%%g
)
rem removes all quotes from JAVA_VERSION
set JAVA_VERSION=!JAVA_VERSION:"=!
for /f "delims=.-_ tokens=1-2" %%v in ("!JAVA_VERSION!") do (
if /I "%%v" EQU "1" (
set JAVA_VERSION=%%w
) else (
set JAVA_VERSION=%%v
)
)
exit /B 0
:checkjava
set /a required_version=6
if /I !JAVA_VERSION! GEQ !required_version! (
exit /B 0
)
echo.
echo The Java Development Kit ^(JDK^) installation you have is not up to date.
echo sbt requires at least version !required_version!+, you have
echo version "!JAVA_VERSION!"
echo.
echo Please go to http://www.oracle.com/technetwork/java/javase/downloads/ and download
echo a valid JDK and install before running sbt.
echo.
exit /B 1
:copyrt
if /I !JAVA_VERSION! GEQ 9 (
set "rtexport=!SBT_BIN_DIR!java9-rt-export.jar"
"!_JAVACMD!" !_JAVA_OPTS! !_SBT_OPTS! -jar "!rtexport!" --rt-ext-dir > "%TEMP%.\rtext.txt"
set /p java9_ext= < "%TEMP%.\rtext.txt"
set "java9_rt=!java9_ext!\rt.jar"
if not exist "!java9_rt!" (
mkdir "!java9_ext!"
"!_JAVACMD!" !_JAVA_OPTS! !_SBT_OPTS! -jar "!rtexport!" "!java9_rt!"
)
set _JAVA_OPTS=!_JAVA_OPTS! -Dscala.ext.dirs="!java9_ext!"
)
exit /B 0
:sync_preloaded
if not defined init_sbt_version (
rem FIXME: better !init_sbt_version! detection
FOR /F "tokens=* usebackq" %%F IN (`dir /b "!SBT_HOME!\lib\local-preloaded\org\scala-sbt\sbt" /B`) DO (
SET init_sbt_version=%%F
)
)
set PRELOAD_SBT_JAR="%UserProfile%\.sbt\preloaded\org\scala-sbt\sbt\!init_sbt_version!\"
if /I !JAVA_VERSION! GEQ 8 (
where robocopy >nul 2>nul
if %ERRORLEVEL% EQU 0 (
if not exist !PRELOAD_SBT_JAR! (
if exist "!SBT_HOME!\lib\local-preloaded\" (
robocopy "!SBT_HOME!\lib\local-preloaded" "%UserProfile%\.sbt\preloaded" /E >nul 2>nul
)
)
)
)
exit /B 0
:usage
for /f "tokens=3 usebackq" %%g in (`CALL "!_JAVACMD!" -Xms32M -Xmx32M -version 2^>^&1 ^| findstr /i version`) do (
set FULL_JAVA_VERSION=%%g
)
echo.
echo Usage: %~n0 [options]
echo.
echo -h ^| --help print this message
echo -v ^| --verbose this runner is chattier
echo -V ^| --version print sbt version information
echo --numeric-version print the numeric sbt version (sbt sbtVersion)
echo --script-version print the version of sbt script
echo -d ^| --debug set sbt log level to debug
echo -debug-inc ^| --debug-inc
echo enable extra debugging for the incremental debugger
echo --no-colors disable ANSI color codes
echo --color=auto^|always^|true^|false^|never
echo enable or disable ANSI color codes ^(sbt 1.3 and above^)
echo --supershell=auto^|always^|true^|false^|never
echo enable or disable supershell ^(sbt 1.3 and above^)
echo --traces generate Trace Event report on shutdown ^(sbt 1.3 and above^)
echo --timings display task timings report on shutdown
echo --sbt-create start sbt even if current directory contains no sbt project
echo --sbt-dir ^<path^> path to global settings/plugins directory ^(default: ~/.sbt^)
echo --sbt-boot ^<path^> path to shared boot directory ^(default: ~/.sbt/boot in 0.11 series^)
echo --ivy ^<path^> path to local Ivy repository ^(default: ~/.ivy2^)
echo --mem ^<integer^> set memory options ^(default: %sbt_default_mem%^)
echo --no-share use all local caches; no sharing
echo --no-global uses global caches, but does not use global ~/.sbt directory.
echo --jvm-debug ^<port^> enable on JVM debugging, open at the given port.
rem echo --batch disable interactive mode
echo.
echo # sbt version ^(default: from project/build.properties if present, else latest release^)
echo --sbt-version ^<version^> use the specified version of sbt
echo --sbt-jar ^<path^> use the specified jar as the sbt launcher
echo.
echo # java version ^(default: java from PATH, currently !FULL_JAVA_VERSION!^)
echo --java-home ^<path^> alternate JAVA_HOME
echo.
echo # jvm options and output control
echo JAVA_OPTS environment variable, if unset uses "!default_java_opts!"
echo .jvmopts if this file exists in the current directory, its contents
echo are appended to JAVA_OPTS
echo SBT_OPTS environment variable, if unset uses "!default_sbt_opts!"
echo .sbtopts if this file exists in the current directory, its contents
echo are prepended to the runner args
echo !SBT_CONFIG!
echo if this file exists, it is prepended to the runner args
echo -Dkey=val pass -Dkey=val directly to the java runtime
rem echo -J-X pass option -X directly to the java runtime
rem echo ^(-J is stripped^)
rem echo -S-X add -X to sbt's scalacOptions ^(-S is stripped^)
echo.
echo In the case of duplicated or conflicting options, the order above
echo shows precedence: JAVA_OPTS lowest, command line options highest.
echo.
@endlocal
exit /B 1
:set_sbt_version
rem set project sbtVersion
for /F "usebackq tokens=2" %%G in (`CALL "!_JAVACMD!" -jar "!sbt_jar!" "sbtVersion" 2^>^&1`) do set "sbt_version=%%G"
exit /B 0
:error
@endlocal
exit /B 1
:end
@endlocal
exit /B 0