jruby/bin/jruby.bash at parallel_boot · MSNexploder/jruby · GitHub

History

executable file

405 lines (356 loc) · 11.2 KB

Raw

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

#!/usr/bin/env bash

# -----------------------------------------------------------------------------

# jruby.bash - Start Script for the JRuby interpreter

# Environment Variable Prequisites

# JRUBY_OPTS (Optional) Default JRuby command line args

# JRUBY_SHELL Where/What is system shell

# JAVA_HOME Must point at your Java Development Kit installation.

# -----------------------------------------------------------------------------

cygwin=false

# ----- Identify OS we are running under --------------------------------------

case "`uname`" in

CYGWIN*) cygwin=true;;

Darwin) darwin=true;;

MINGW*) jruby.exe "$@"; exit $?;;

esac

# ----- Verify and Set Required Environment Variables -------------------------

if [ -z "$JAVA_VM" ]; then

JAVA_VM=-client

# get the absolute path of the executable

SELF_PATH=$(builtin cd -P -- "$(dirname -- "$0")" >/dev/null && pwd -P) && SELF_PATH=$SELF_PATH/$(basename -- "$0")

# resolve symlinks

while [ -h $SELF_PATH ]; do

# 1) cd to directory of the symlink

# 2) cd to the directory of where the symlink points

# 3) get the pwd

# 4) append the basename

DIR=$(dirname -- "$SELF_PATH")

SYM=$(readlink $SELF_PATH)

SELF_PATH=$(cd $DIR && cd $(dirname -- "$SYM") && pwd)/$(basename -- "$SYM")

done

PRG=$SELF_PATH

JRUBY_HOME_1=`dirname "$PRG"` # the ./bin dir

if [ "$JRUBY_HOME_1" = '.' ] ; then

cwd=`pwd`

JRUBY_HOME=`dirname $cwd` # JRUBY-2699

else

JRUBY_HOME=`dirname "$JRUBY_HOME_1"` # the . dir

if [ -z "$JRUBY_OPTS" ] ; then

JRUBY_OPTS=""

JRUBY_OPTS_SPECIAL="--ng" # space-separated list of special flags

unset JRUBY_OPTS_TEMP

function process_special_opts {

case $1 in

--ng) nailgun_client=true;;

*) break;;

esac

}

for opt in ${JRUBY_OPTS[@]}; do

for special in ${JRUBY_OPTS_SPECIAL[@]}; do

if [ $opt != $special ]; then

JRUBY_OPTS_TEMP="${JRUBY_OPTS_TEMP} $opt"

else

# make sure flags listed in JRUBY_OPTS_SPECIAL are processed

case "$opt" in

--ng)

process_special_opts $opt;;

esac

done

if [ $opt == "-server" ]; then # JRUBY-4204

JAVA_VM="-server"

done

JRUBY_OPTS=${JRUBY_OPTS_TEMP}

if [ -z "$JAVACMD" ] ; then

if [ -z "$JAVA_HOME" ] ; then

JAVACMD='java'

else

if $cygwin; then

JAVACMD="`cygpath -u "$JAVA_HOME"`/bin/java"

else

JAVACMD="$JAVA_HOME/bin/java"

if [ -z "$JAVA_MEM" ] ; then

JAVA_MEM=-Xmx500m

if [ -z "$JAVA_STACK" ] ; then

JAVA_STACK=-Xss2048k

# process JAVA_OPTS

unset JAVA_OPTS_TEMP

JAVA_OPTS_TEMP=""

for opt in ${JAVA_OPTS[@]}; do

case $opt in

-server)

JAVA_VM="-server";;

-Xmx*)

JAVA_MEM=$opt;;

-Xms*)

JAVA_MEM_MIN=$opt;;

-Xss*)

JAVA_STACK=$opt;;

JAVA_OPTS_TEMP="${JAVA_OPTS_TEMP} $opt";;

esac

done

JAVA_OPTS=$JAVA_OPTS_TEMP

# If you're seeing odd exceptions, you may have a bad JVM install.

# Uncomment this and report the version to the JRuby team along with error.

#$JAVACMD -version

JRUBY_SHELL=/bin/sh

# ----- Set Up The Boot Classpath -------------------------------------------

CP_DELIMITER=":"

# add main jruby jar to the bootclasspath

for j in "$JRUBY_HOME"/lib/jruby.jar "$JRUBY_HOME"/lib/jruby-complete.jar; do

if [ ! -e "$j" ]; then

continue

if [ "$JRUBY_CP" ]; then

JRUBY_CP="$JRUBY_CP$CP_DELIMITER$j"

else

JRUBY_CP="$j"

if [ $JRUBY_ALREADY_ADDED ]; then

echo "WARNING: more than one JRuby JAR found in lib directory"

JRUBY_ALREADY_ADDED=true

done

if $cygwin; then

JRUBY_CP=`cygpath -p -w "$JRUBY_CP"`

# ----- Set Up The System Classpath -------------------------------------------

if [ "$JRUBY_PARENT_CLASSPATH" != "" ]; then

# Use same classpath propagated from parent jruby

CP=$JRUBY_PARENT_CLASSPATH

else

# add other jars in lib to CP for command-line execution

for j in "$JRUBY_HOME"/lib/*.jar; do

if [ "$j" == "$JRUBY_HOME"/lib/jruby.jar ]; then

continue

if [ "$j" == "$JRUBY_HOME"/lib/jruby-complete.jar ]; then

continue

if [ "$CP" ]; then

CP="$CP$CP_DELIMITER$j"

else

CP="$j"

done

if [ "$CP" != "" ] && $cygwin; then

CP=`cygpath -p -w "$CP"`

if $cygwin; then

# switch delimiter only after building Unix style classpaths

CP_DELIMITER=";"

# ----- Execute The Requested Command -----------------------------------------

JAVA_ENCODING=""

declare -a java_args

declare -a ruby_args

mode=""

JAVA_CLASS_JRUBY_MAIN=org.jruby.Main

java_class=$JAVA_CLASS_JRUBY_MAIN

JAVA_CLASS_NGSERVER=com.martiansoftware.nailgun.NGServer

# Split out any -J argument for passing to the JVM.

# Scanning for args is aborted by '--'.

set -- $JRUBY_OPTS "$@"

while [ $# -gt 0 ]

case "$1" in

# Stuff after '-J' in this argument goes to JVM

-J*)

val=${1:2}

if [ "${val:0:4}" = "-Xmx" ]; then

JAVA_MEM=$val

elif [ "${val:0:4}" = "-Xms" ]; then

JAVA_MEM_MIN=$val

elif [ "${val:0:4}" = "-Xss" ]; then

JAVA_STACK=$val

elif [ "${val}" = "" ]; then

$JAVACMD -help

echo "(Prepend -J in front of these options when using 'jruby' command)"

exit

elif [ "${val}" = "-X" ]; then

$JAVACMD -X

echo "(Prepend -J in front of these options when using 'jruby' command)"

exit

elif [ "${val}" = "-classpath" ]; then

CP="$CP$CP_DELIMITER$2"

CLASSPATH=""

shift

elif [ "${val}" = "-cp" ]; then

CP="$CP$CP_DELIMITER$2"

CLASSPATH=""

shift

else

if [ "${val:0:3}" = "-ea" ]; then

VERIFY_JRUBY="yes"

elif [ "${val:0:16}" = "-Dfile.encoding=" ]; then

JAVA_ENCODING=$val

java_args=("${java_args[@]}" "${1:2}")

;;

# Match -Xa.b.c=d to translate to -Da.b.c=d as a java option

-X*)

val=${1:2}

if expr "$val" : '.*[.]' > /dev/null; then

java_args=("${java_args[@]}" "-Djruby.${val}")

else

ruby_args=("${ruby_args[@]}" "-X${val}")

;;

# Match switches that take an argument

-C|-e|-I|-S) ruby_args=("${ruby_args[@]}" "$1" "$2"); shift ;;

# Match same switches with argument stuck together

-e*|-I*|-S*) ruby_args=("${ruby_args[@]}" "$1" ) ;;

# Run with JMX management enabled

--manage)

java_args=("${java_args[@]}" "-Dcom.sun.management.jmxremote")

java_args=("${java_args[@]}" "-Djruby.management.enabled=true") ;;

# Don't launch a GUI window, no matter what

--headless)

java_args=("${java_args[@]}" "-Djava.awt.headless=true") ;;

# Run under JDB

--jdb)

if [ -z "$JAVA_HOME" ] ; then

JAVACMD='jdb'

else

if $cygwin; then

JAVACMD="`cygpath -u "$JAVA_HOME"`/bin/jdb"

else

JAVACMD="$JAVA_HOME/bin/jdb"

java_args=("${java_args[@]}" "-sourcepath" "$JRUBY_HOME/lib/ruby/1.8:.")

JRUBY_OPTS=("${JRUBY_OPTS[@]}" "-X+C") ;;

--client)

JAVA_VM=-client ;;

--server)

JAVA_VM=-server ;;

--noclient) # JRUBY-4296

unset JAVA_VM ;; # For IBM JVM, neither '-client' nor '-server' is applicable

--sample)

java_args=("${java_args[@]}" "-Xprof") ;;

--ng-server)

# Start up as Nailgun server

java_class=$JAVA_CLASS_NGSERVER

VERIFY_JRUBY=true ;;

--ng)

# Use native Nailgun client to toss commands to server

process_special_opts "--ng" ;;

# Special pass --1.9 along so when processing cygwin we don't think it is

# a file (this is fairly gross that we special case this -- my bash-fu

# is weak)

--1.9) mode=--1.9 ;;

# Abort processing on the double dash

--) break ;;

# Other opts go to ruby

-*) ruby_args=("${ruby_args[@]}" "$1") ;;

# Abort processing on first non-opt arg

*) break ;;

esac

shift

done

# Force file.encoding to UTF-8 when on Mac, since Apple JDK defaults to MacRoman (JRUBY-3576)

if [[ $darwin && -z "$JAVA_ENCODING" ]]; then

java_args=("${java_args[@]}" "-Dfile.encoding=UTF-8")

# Append the rest of the arguments

ruby_args=("${ruby_args[@]}" "$@")

# Put the ruby_args back into the position arguments $1, $2 etc

set -- "${ruby_args[@]}"

JAVA_OPTS="$JAVA_OPTS $JAVA_MEM $JAVA_MEM_MIN $JAVA_STACK"

JFFI_BOOT=""

if [ -d "$JRUBY_HOME/lib/native/" ]; then

for d in $JRUBY_HOME/lib/native/*`uname -s`; do

if [ -z "$JFFI_BOOT" ]; then

JFFI_BOOT="$d"

else

JFFI_BOOT="$JFFI_BOOT:$d"

done

JFFI_OPTS="-Djffi.boot.library.path=$JFFI_BOOT"

if $cygwin; then

JRUBY_HOME=`cygpath --mixed "$JRUBY_HOME"`

JRUBY_SHELL=`cygpath --mixed "$JRUBY_SHELL"`

if [[ ( "${1:0:1}" = "/" ) && ( ( -f "$1" ) || ( -d "$1" )) ]]; then

win_arg=`cygpath -w "$1"`

shift

win_args=("$win_arg" "$@")

set -- "${win_args[@]}"

# fix JLine to use UnixTerminal

stty -icanon min 1 -echo > /dev/null 2>&1

if [ $? = 0 ]; then

JAVA_OPTS="$JAVA_OPTS -Djline.terminal=jline.UnixTerminal"

if [ "$nailgun_client" != "" ]; then

if [ -f $JRUBY_HOME/tool/nailgun/ng ]; then

exec $JRUBY_HOME/tool/nailgun/ng org.jruby.util.NailMain $mode "$@"

else

echo "error: ng executable not found; run 'make' in ${JRUBY_HOME}/tool/nailgun"

exit 1

else

if [ "$VERIFY_JRUBY" != "" ]; then

if [ "$PROFILE_ARGS" != "" ]; then

echo "Running with instrumented profiler"

if [[ "${java_class:-}" == "${JAVA_CLASS_NGSERVER:-}" && -n "${JRUBY_OPTS:-}" ]]; then

echo "warning: starting a nailgun server; discarding JRUBY_OPTS: ${JRUBY_OPTS}"

JRUBY_OPTS=''

"$JAVACMD" $PROFILE_ARGS $JAVA_OPTS "$JFFI_OPTS" "${java_args[@]}" -classpath "$JRUBY_CP$CP_DELIMITER$CP$CP_DELIMITER$CLASSPATH" \

"-Djruby.home=$JRUBY_HOME" \

"-Djruby.lib=$JRUBY_HOME/lib" -Djruby.script=jruby \

"-Djruby.shell=$JRUBY_SHELL" \

$java_class $JRUBY_OPTS "$@"

# Record the exit status immediately, or it will be overridden.

JRUBY_STATUS=$?

if [ "$PROFILE_ARGS" != "" ]; then

echo "Profiling results:"

cat profile.txt

rm profile.txt

if $cygwin; then

stty icanon echo > /dev/null 2>&1

exit $JRUBY_STATUS

else

if $cygwin; then

# exec doed not work correctly with cygwin bash

"$JAVACMD" $JAVA_OPTS "$JFFI_OPTS" "${java_args[@]}" -Xbootclasspath/a:"$JRUBY_CP" -classpath "$CP$CP_DELIMITER$CLASSPATH" \

"-Djruby.home=$JRUBY_HOME" \

"-Djruby.lib=$JRUBY_HOME/lib" -Djruby.script=jruby \

"-Djruby.shell=$JRUBY_SHELL" \

$java_class $mode "$@"

# Record the exit status immediately, or it will be overridden.

JRUBY_STATUS=$?

stty icanon echo > /dev/null 2>&1

exit $JRUBY_STATUS

else

exec "$JAVACMD" $JAVA_OPTS "$JFFI_OPTS" "${java_args[@]}" -Xbootclasspath/a:"$JRUBY_CP" -classpath "$CP$CP_DELIMITER$CLASSPATH" \

"-Djruby.home=$JRUBY_HOME" \

"-Djruby.lib=$JRUBY_HOME/lib" -Djruby.script=jruby \

"-Djruby.shell=$JRUBY_SHELL" \

$java_class $mode "$@"

# Be careful adding code down here, you might override the exit

# status of the jruby invocation.

jruby/bin/jruby.bash at parallel_boot · MSNexploder/jruby · GitHub

Expand file tree

Breadcrumbs

jruby.bash

Latest commit

History

Breadcrumbs

jruby.bash

File metadata and controls