jruby-launcher 0.9.9-java

data/Makefile

@@ -0,0 +1,106 @@
+# These line gets substituted with the actual Config::CONFIG items location by extconf.rb
+PREFIX = notspecified
+BINDIR = $(PREFIX)/bin
+SITELIBDIR = $(PREFIX)/lib/ruby/site_ruby/1.8
+
+ifeq (true,$(shell test -x $(BINDIR)/jruby && echo true))
+RAKE=$(BINDIR)/jruby -S rake
+else
+RAKE=rake
+endif
+
+build: .build-post
+
+.build-pre:
+
+.build-post: .build-impl build-exe test
+
+build-exe:
+	@if [ "$(findstring mingw, $(CONF))" ]; then											\
+	${MAKE} -f ${SUB_CONFMK} SUBPROJECTS=${SUBPROJECTS} jruby.exe jrubyw.exe;					\
+	if [ -d ../jruby ]; then cp jruby.exe jrubyw.exe jruby.dll ../jruby/bin/; fi;					\
+	if [ -d D:/work/jruby-dev/jruby ]; then cp jruby.exe jrubyw.exe jruby.dll D:/work/jruby-dev/jruby/bin/; fi;	\
+	fi
+
+jruby.res: resources/jruby.rc
+	windres $^ -O coff -o $@
+
+jruby.exe: jrubyexe.cpp nbexecloader.h utilsfuncs.cpp utilsfuncswin.cpp jruby.res
+	g++ $(CXXFLAGS) $^ -s -o $@ $(LDLIBSOPTIONS)
+
+jrubyw.exe: jrubyexe.cpp nbexecloader.h utilsfuncs.cpp utilsfuncswin.cpp jruby.res
+	g++ $(CXXFLAGS) -DJRUBYW -mwindows $^ -s -o $@ $(LDLIBSOPTIONS)
+
+install:
+	@if [ ! -f ./jruby ]; then echo "Please run 'make' first."; exit 1; fi
+	@if [ x$(BINDIR) = xnotspecified/bin ]; then echo "Please define where to install by passing PREFIX=<jruby-home>."; exit 1; fi
+	@if [ ! -w $(BINDIR) ]; then echo "'$(BINDIR)' does not exist or cannot write to '$(BINDIR)'."; exit 1; fi
+	@if [ -f $(BINDIR)/jruby -a ! -w $(BINDIR)/jruby ]; then echo "Cannot write to '$(BINDIR)/jruby'."; exit 1; fi
+	cp ./jruby $(BINDIR)/jruby
+	@if [ x$(SITELIBDIR) = xnotspecified/lib/ruby/site_ruby/1.8 ]; then echo "Please define where to install by passing PREFIX=<jruby-home>."; exit 1; fi
+	@if [ ! -w $(SITELIBDIR) ]; then echo "'$(SITELIBDIR)' does not exist or cannot write to '$(SITELIBDIR)'."; exit 1; fi
+	cp ./lib/rubygems/defaults/jruby_native.rb $(SITELIBDIR)/rubygems/defaults
+
+test:
+	$(RAKE)
+
+# Universal binary on OSX
+FAT_ARCHES=i386 ppc x86_64
+
+fat: $(FAT_ARCHES)
+	lipo -create $(foreach arch,$(FAT_ARCHES),build/unix/Darwin-$(arch)/jruby-launcher) -output jruby
+	$(RAKE)
+
+$(FAT_ARCHES):
+	$(MAKE) -f $(SUB_CONFMK) CND_PLATFORM=Darwin-$@ CFLAGS="-arch $@" build/unix/Darwin-$@/jruby-launcher
+
+clean: .clean-post
+
+.clean-pre:
+	-rm -rf build/*
+
+.clean-post: .clean-impl
+	rm -f *.exe *.res
+
+clobber: .clobber-post
+
+.clobber-pre:
+
+.clobber-post: .clobber-impl
+
+all: .all-post
+
+.all-pre:
+
+.all-post: .all-impl
+
+help: .help-post
+
+.help-pre:
+
+.help-post: .help-impl
+
+# Use the manually-maintained inc/*.mk makefiles.
+# Pass NETBEANS=true on the command-line to use NB's generated
+# nbproject/*.mk
+
+ifdef NETBEANS
+SUB_IMPLMK=nbproject/Makefile-impl.mk
+else
+SUB_IMPLMK=inc/Makefile-impl.mk
+SUB_CONFMK=inc/Makefile-rules.mk
+endif
+
+# include project implementation makefile
+include $(SUB_IMPLMK)
+
+# Pick conf based on OS. for mingw64, must manually override for now.
+ifeq ($(OS),Windows_NT)
+CONF=mingw
+else
+CONF=unix
+endif
+
+ifdef NETBEANS
+SUB_CONFMK=nbproject/Makefile-${CONF}.mk
+endif

data/README.txt

@@ -0,0 +1,61 @@
+JRuby Native Launcher
+
+== Motivation
+
+Maintaning JRuby.BAT was, well, to put it mildly, unpleasant. We had
+tens of bugs due to BAT limitations, we had weird behaviors depending
+on the version of Windows, we had a bunch of regressions.
+
+See http://jira.codehaus.org/browse/JRUBY-4100 for more details.
+
+On UNIX platforms, we had problems because a shell-script can't be put
+as a path in the shebang and couldn't take arguments. (#!/usr/bin/env
+jruby -w)
+
+We also wanted to DRY up argument handling, even if it meant ditching
+shell script and writing in lowest-common-denominator C++ (!).
+
+== Compile
+
+On UNIX, you should be able to just type 'make' and a 'jruby' binary
+will be created in the project directory. Copy this to
+$JRUBY_HOME/bin. On Windows, you should also be able to type 'make' if
+you have the MinGW compiler toolkit installed.
+
+Or, open the project in Netbeans 6.8 (with C/C++ plugin installed). If
+Netbeans warns that no compilers found, follow the instructions and
+install the required compilers. Currenty, we support MinGW. More info
+here:
+
+http://netbeans.org/community/releases/68/cpp-setup-instructions.html
+
+Then, just build it, and you're ready to go. jruby.exe, jrubyw.exe and
+jruby.dll will be created, they need to be copied into $JRUBY_HOME/bin
+directory.
+
+Both, 32-bit and 64-bit compilers are supported. Great version of
+64-bit mingw can be found here: http://www.cadforte.com/system64.html
+
+To build 64-bit version of the launcher, use the following from the
+command line:
+
+  make CONF=mingw64
+
+== Run
+
+The launcher provides a great logger, use it like this:
+
+  jruby -Xtrace LOG_FILE.log ....
+
+== TODO
+
+See TODO.txt file for things that need to be done before this launcher
+could replace jruby.bat.
+
+== Thanks
+
+The original code is by Netbeans project.
+
+== License
+
+Read the COPYING file.

data/Rakefile

@@ -0,0 +1,27 @@
+require 'spec/rake/spectask'
+require 'rake/gempackagetask'
+require 'date'
+
+Spec::Rake::SpecTask.new
+
+task :default => :spec
+
+load './lib/jruby-launcher.rb'
+
+gemspec = Gem::Specification.new do |s|
+  s.name = %q{jruby-launcher}
+  s.platform = Gem::Platform.new("java")
+  s.version = JRubyLauncher::VERSION
+  s.authors = ["Nick Sieger", "Vladimir Sizikov"]
+  s.date = Date.today.to_s
+  s.description = %q{Builds and installs a native launcher for JRuby on your system}
+  s.summary = %q{Native launcher for JRuby}
+  s.email = ["nick@nicksieger.com", "vsizikov@gmail.com"]
+  s.extensions = ["extconf.rb"]
+  s.files = FileList["COPYING", "README.txt", "Makefile", "Rakefile", "*.c", "*.cpp", "*.h", "inc/*.*", "**/*.rb", "resources/*.*"]
+  s.homepage = %q{http://jruby.org}
+  s.rubyforge_project = %q{jruby-extras}
+end
+
+Rake::GemPackageTask.new(gemspec) do |pkg|
+end

data/argnames.h

@@ -0,0 +1,37 @@
+/*
+ * File:   argnames.h
+ * Author: Holy
+ *
+ * Created on 4. prosinec 2008, 14:13
+ */
+
+#ifndef _ARGNAMES_H
+#define _ARGNAMES_H
+
+/* Standard Java classpath options */
+#define ARG_NAME_CP "-J-cp"
+#define ARG_NAME_CLASSPATH "-J-classpath"
+
+/* These are windows-launcher-specific args. They should be prefixed with -X
+   so that they don't clash with normal Ruby args (like --trace for Rake). */
+#define ARG_NAME_SEPAR_PROC "-Xfork-java"
+#define ARG_NAME_CONSOLE    "-Xconsole"
+#define ARG_NAME_LAUNCHER_LOG "-Xtrace"
+#define ARG_NAME_BOOTCLASS "-Xbootclass"
+#define ARG_NAME_JDKHOME "-Xjdkhome"
+#define ARG_NAME_CP_PREPEND "-Xcp:p"
+#define ARG_NAME_CP_APPEND "-Xcp:a"
+#define ARG_NAME_CMD_ONLY "-Xcommand"
+
+/* Below are standard JRuby args handled by the launcher. */
+#define ARG_NAME_SERVER "--server"
+#define ARG_NAME_CLIENT "--client"
+#define ARG_NAME_SAMPLE "--sample"
+#define ARG_NAME_MANAGE "--manage"
+#define ARG_NAME_HEADLESS "--headless"
+#define ARG_NAME_PROFILE "--profile"
+#define ARG_NAME_NG_SERVER "--ng-server"
+#define ARG_NAME_NG "--ng"
+
+#endif  /* _ARGNAMES_H */
+

data/argparser.cpp

@@ -0,0 +1,559 @@
+/*
+ * Copyright 2009-2010 JRuby Team (www.jruby.org).
+ */
+
+#include <cstring>
+#include <cstdlib>
+#include <memory>
+#include "utilsfuncs.h"
+#include "argparser.h"
+#include "argnames.h"
+
+#ifndef WIN32
+#include <sys/types.h>
+#include <sys/utsname.h>
+#include <dirent.h>
+#define EXEEXT ""
+#else
+#define EXEEXT ".exe"
+#endif
+
+using namespace std;
+
+const char *ArgParser::HELP_MSG =
+"\nJRuby Launcher usage: jruby" EXEEXT " {options} arguments\n\
+Options:\n\
+  -Xhelp                show this help\n\
+  -Xjdkhome <path>      path to JDK\n\
+  -J<jvm_option>        pass <jvm_option> to JVM\n\
+\n\
+  -Xcp   <classpath>    set the classpath\n\
+  -Xcp:p <classpath>    prepend <classpath> to classpath\n\
+  -Xcp:a <classpath>    append <classpath> to classpath\n\
+\n\
+  -Xfork-java           run java in separate process\n\
+  -Xtrace <path>        path for launcher log (for troubleshooting)\n\
+  -Xcommand             just print the equivalent java command and exit\n"
+#ifdef WIN32
+"  -Xconsole <mode>      jrubyw console attach mode (new|attach|suppress)\n\n"
+#endif
+"To see general JRuby options, type 'jruby -h' or 'jruby --help'.\n\
+--------------------------------------------------------------------\n\n";
+
+const char *ArgParser::REQ_JAVA_VERSION = "1.5";
+
+const char *ArgParser::OPT_JDK_HOME = "-Djdk.home=";
+const char *ArgParser::OPT_JRUBY_HOME = "-Djruby.home=";
+const char *ArgParser::OPT_JRUBY_COMMAND_NAME = "-Dsun.java.command=";
+
+const char *ArgParser::OPT_CLASS_PATH = "-Djava.class.path=";
+const char *ArgParser::OPT_BOOT_CLASS_PATH = "-Xbootclasspath/a:";
+
+const char *ArgParser::OPT_JFFI_PATH = "-Djffi.boot.library.path=";
+const char *ArgParser::OPT_JRUBY_SHELL = "-Djruby.shell=";
+const char *ArgParser::OPT_JRUBY_SCRIPT = "-Djruby.script=";
+const char *ArgParser::MAIN_CLASS = "org/jruby/Main";
+const char *ArgParser::DEFAULT_EXECUTABLE = "jruby";
+
+ArgParser::ArgParser()
+    : separateProcess(false)
+    , nailgunClient(false)
+    , nailgunServer(false)
+    , printCommandLine(false)
+{
+}
+
+ArgParser::ArgParser(const ArgParser& orig) {
+}
+
+ArgParser::~ArgParser() {
+}
+
+void ArgParser::addEnvVarToOptions(std::list<std::string> & optionsList, const char * envvar) {
+    const char * value = getenv(envvar);
+    string opts("");
+    if (value) {
+        opts = value;
+    }
+
+    if (opts.size() > 0) {
+        if (opts[0] == '"' || opts[0] == '\'') {
+            char quote = opts[0];
+            if (opts[opts.size() - 1] == quote) {
+                opts = opts.substr(1, opts.size() - 2);
+            }
+        }
+
+        size_t start = 0, pos = 0;
+        while ((pos = opts.find(' ', start)) != string::npos) {
+            string part(opts.substr(start, pos - start));
+            if (part.size() > 0) {
+                logMsg("%s += %s", envvar, part.c_str());
+                optionsList.push_back(part);
+            }
+            start = pos + 1;
+        }
+        if (start < opts.size()) {
+            string part(opts.substr(start));
+            if (part.size() > 0) {
+                logMsg("%s += %s", envvar, part.c_str());
+                optionsList.push_back(part);
+            }
+        }
+    }
+}
+
+#ifdef __MACH__
+#include <mach-o/dyld.h>
+#endif
+
+bool ArgParser::initPlatformDir() {
+#ifdef WIN32
+    char path[MAX_PATH] = "";
+    getCurrentModulePath(path, MAX_PATH);
+#else
+    char path[PATH_MAX] = "";
+    bool found = false;
+
+    // first try via linux /proc/self/exe
+    logMsg("initPlatformDir: trying /proc/self/exe");
+    found = readlink("/proc/self/exe", path, PATH_MAX) != -1;
+
+#ifdef __MACH__
+    uint32_t sz = PATH_MAX;
+    if (_NSGetExecutablePath(path, &sz) == 0) { // OSX-specific
+        logMsg("initPlatformDir: using _NSGetExecutablePath");
+        string tmpPath(path);
+        realpath(tmpPath.c_str(), path);
+        found = true;
+    }
+#endif
+
+#ifdef __SUNOS__
+    const char* execname = getexecname();
+    if (execname) {
+        logMsg("initPlatformDir: using getexecname");
+        char * dst = path;
+        if (execname[0] != '/') {
+            getcwd(path, PATH_MAX - strlen(execname) - 2);
+            dst = path + strlen(path);
+            *dst++ = '/';
+        }
+
+        strncpy(dst, execname, strlen(execname));
+        found = true;
+    }
+#endif
+
+    if (!found && platformDir[0] == '/') { // argv[0]: absolute path
+        logMsg("initPlatformDir: argv[0] appears to be an absolute path");
+        strncpy(path, platformDir.c_str(), PATH_MAX);
+        found = true;
+    }
+
+    if (!found && platformDir.find('/') != string::npos) { // argv[0]: relative path
+        logMsg("initPlatformDir: argv[0] appears to be a relative path");
+        getcwd(path, PATH_MAX - platformDir.length() - 1);
+        strncpy(path + strlen(path), platformDir.c_str(), platformDir.length());
+        found = true;
+    }
+
+    if (!found) {               // try via PATH search
+        logMsg("initPlatformDir: trying to find executable on PATH");
+        char * location = findOnPath(platformDir.c_str());
+        if (location != NULL) {
+            strncpy(path, location, PATH_MAX);
+            free(location);
+            found = true;
+        }
+    }
+
+    if (!found) {               // try via JRUBY_HOME
+        if (getenv("JRUBY_HOME") != NULL) {
+            logMsg("initPlatformDir: trying JRUBY_HOME environment variable");
+            strncpy(path, getenv("JRUBY_HOME"), PATH_MAX - 11);
+            strncpy(path + strlen(path), "/bin/jruby", 10);
+            found = true;
+        }
+    }
+
+    if (!fileExists(path)) {
+        printToConsole("Could not figure out a proper location for JRuby.\n"
+                       "Try `jruby -Xtrace trace.log ...` and view trace.log for details.");
+        return false;
+    }
+#endif
+
+    logMsg("Module: %s", path);
+    char *bslash = strrchr(path, FILE_SEP);
+    if (!bslash) {
+        return false;
+    }
+    *bslash = '\0';
+    bslash = strrchr(path, FILE_SEP);
+    if (!bslash) {
+        return false;
+    }
+    *bslash = '\0';
+    platformDir = path;
+    logMsg("Platform dir: %s", platformDir.c_str());
+    return true;
+}
+
+bool ArgParser::parseArgs(int argc, char *argv[]) {
+    list<string> args;
+
+#define CHECK_ARG                                                       \
+    it++;								\
+    if (it == args.end() || it->at(0) == '-') {				\
+        logErr(false, true, "Argument is missing for \"%s\" option.", (--it)->c_str()); \
+        return false;                                                   \
+    }									\
+    it--;
+#define INCR ++it, ++i
+
+    addEnvVarToOptions(javaOptions, "JAVA_OPTS");
+    addEnvVarToOptions(args, "JRUBY_OPTS");
+    addToArgList(args, argc, argv);
+
+    logMsg("Parsing arguments:");
+    for (list<string>::iterator it = args.begin(); it != args.end(); ++it) {
+        logMsg("\t%s", it->c_str());
+    }
+
+    bool doneScanning = false;
+
+    int i = 0;
+    for (list<string>::iterator it = args.begin(); it != args.end(); INCR) {
+        if (doneScanning) {
+            progArgs.push_back(*it);
+        } else if (it->compare("--") == 0 || it->at(0) != '-') {
+            progArgs.push_back(*it);
+            doneScanning = true;
+        } else if (it->compare(ARG_NAME_SEPAR_PROC) == 0) {
+            separateProcess = true;
+            logMsg("Run Java in separater process");
+        } else if (it->compare(ARG_NAME_CMD_ONLY) == 0) {
+            printCommandLine = true;
+        } else if (it->compare(ARG_NAME_LAUNCHER_LOG) == 0) {
+            // We only check the validity of args here,
+            // the actual parsing and setting the log file
+            // is done earlier, in checkLoggingArg()
+            CHECK_ARG;
+            INCR;
+        } else if (it->compare(ARG_NAME_BOOTCLASS) == 0) {
+            CHECK_ARG;
+	    INCR;
+            bootclass = *it;
+        } else if (it->compare(ARG_NAME_JDKHOME) == 0) {
+            CHECK_ARG;
+	    INCR;
+            jdkhome = *it;
+        } else if (it->compare(ARG_NAME_CP_PREPEND) == 0) {
+            CHECK_ARG;
+            if (!cpBefore.empty()) {
+                cpBefore += PATH_SEP;
+            }
+	    INCR;
+            cpBefore += *it;
+        } else if (it->compare(ARG_NAME_CP_APPEND) == 0) {
+            CHECK_ARG;
+            if (!cpAfter.empty()) {
+                cpAfter += PATH_SEP;
+            }
+	    INCR;
+            cpAfter += *it;
+        } else if (it->compare(ARG_NAME_CP) == 0
+		   || it->compare(ARG_NAME_CLASSPATH) == 0) {
+            CHECK_ARG;
+            if (!cpExplicit.empty()) {
+                cpExplicit += PATH_SEP;
+            }
+	    INCR;
+            cpExplicit += *it;
+        } else if (it->compare(ARG_NAME_SERVER) == 0
+                || it->compare(ARG_NAME_CLIENT) == 0) {
+            javaOptions.push_back(it->substr(1)); // to JVMLauncher, -server instead of --server
+        } else if (it->compare(ARG_NAME_SAMPLE) == 0) {
+            javaOptions.push_back("-Xprof");
+        } else if (it->compare(ARG_NAME_MANAGE) == 0) {
+            javaOptions.push_back("-Dcom.sun.management.jmxremote");
+            javaOptions.push_back("-Djruby.management.enabled=true");
+        } else if (it->compare(ARG_NAME_HEADLESS) == 0) {
+            javaOptions.push_back("-Djava.awt.headless=true");
+        } else if (it->compare(ARG_NAME_PROFILE) == 0 ||
+                it->compare(ARG_NAME_PROFILE "-all") == 0) {
+            std::string filterType = it->length() == strlen(ARG_NAME_PROFILE) ? "ruby" : "all";
+            javaOptions.push_front("-Dprofile.properties=" + platformDir + "/lib/profile-" + filterType + ".properties");
+            javaOptions.push_front("-javaagent:" + platformDir + "/lib/profile.jar");
+            progArgs.push_back("-X+C");
+            printToConsole("Running with instrumented profiler\n");
+        } else if (it->compare(ARG_NAME_NG) == 0) {
+            nailgunClient = true;
+        } else if (it->compare(ARG_NAME_NG_SERVER) == 0) {
+            bootclass = "com/martiansoftware/nailgun/NGServer";
+            javaOptions.push_back("-server");
+            nailgunServer = true;
+        } else if (it->compare(0, 2, "-J", 2) == 0) {
+            javaOptions.push_back(it->substr(2));
+        } else if (strcmp(it->c_str(), "-Xhelp") == 0) {
+            printToConsole(HELP_MSG);
+            if (!appendHelp.empty()) {
+                printToConsole(appendHelp.c_str());
+            }
+            return false;
+        } else {
+            progArgs.push_back(*it);
+        }
+    }
+
+    return true;
+}
+
+void ArgParser::prepareOptions() {
+    string option = OPT_JDK_HOME;
+    option += jdkhome;
+    javaOptions.push_back(option);
+
+    option = OPT_JRUBY_HOME;
+    option += platformDir;
+    javaOptions.push_back(option);
+
+    option = OPT_JRUBY_SCRIPT;
+    option += "jruby";
+    javaOptions.push_back(option);
+
+    option = OPT_JRUBY_SHELL;
+#ifdef WIN32
+    option += "cmd.exe";
+#else
+    const char* shell = getenv("SHELL");
+    if (shell == NULL) {
+        shell = "/bin/sh";
+    }
+    option += shell;
+#endif
+    javaOptions.push_back(option);
+
+    option = OPT_JFFI_PATH;
+#ifdef WIN32
+    option += (platformDir + "\\lib\\native\\i386-Windows;"
+            + platformDir + "\\lib\\native\\x86_64-Windows");
+#else
+    struct utsname name;
+    if (uname(&name) == 0) {
+        string ffiPath, ffiBase(platformDir + "/lib/native");
+        DIR* dir = opendir(ffiBase.c_str());
+        struct dirent* ent;
+        if (dir != NULL) {
+            while ((ent = readdir(dir)) != NULL) {
+                string entry(ent->d_name);
+                if (entry.find(name.sysname) != string::npos) {
+                    if (!ffiPath.empty()) {
+                        ffiPath += PATH_SEP;
+                    }
+                    ffiPath += ffiBase + FILE_SEP + entry;
+                }
+            }
+            closedir(dir);
+        }
+        option += ffiPath;
+    }
+#endif
+    javaOptions.push_back(option);
+
+    setupMaxHeapAndStack();
+
+    constructBootClassPath();
+    constructClassPath();
+
+    if (bootclass.empty()) {
+        bootclass = MAIN_CLASS;
+    }
+
+    // replace '/' by '.' to report a better name to jps/jconsole
+    string cmdName = bootclass;
+    size_t position = cmdName.find("/");
+    while (position != string::npos) {
+      cmdName.replace(position, 1, ".");
+      position = cmdName.find("/", position + 1);
+    }
+
+    option = OPT_JRUBY_COMMAND_NAME;
+    option += cmdName;
+    javaOptions.push_back(option);
+
+    option = OPT_CLASS_PATH;
+    option += classPath;
+    javaOptions.push_back(option);
+
+    if (!bootClassPath.empty()) {
+        option = OPT_BOOT_CLASS_PATH;
+        option += bootClassPath;
+        javaOptions.push_back(option);
+    }
+}
+
+void ArgParser::setupMaxHeapAndStack() {
+    // Hard-coded 500m, 1024k is for consistency with jruby shell script.
+    string heapSize("500m"), stackSize("1024k");
+    bool maxHeap = false, maxStack = false;
+    for (list<string>::iterator it = javaOptions.begin(); it != javaOptions.end(); it++) {
+        if (!maxHeap && strncmp("-Xmx", it->c_str(), 4) == 0) {
+            heapSize = it->substr(4, it->size() - 4);
+            maxHeap = true;
+        }
+        if (!maxStack && strncmp("-Xss", it->c_str(), 4) == 0) {
+            stackSize = it->substr(4, it->size() - 4);
+            maxStack = true;
+        }
+    }
+    if (!maxHeap) {
+        javaOptions.push_back("-Xmx" + heapSize);
+    }
+    if (!maxStack) {
+        javaOptions.push_back("-Xss" + stackSize);
+    }
+    javaOptions.push_back("-Djruby.memory.max=" + heapSize);
+    javaOptions.push_back("-Djruby.stack.max=" + stackSize);
+}
+
+void ArgParser::constructBootClassPath() {
+    logMsg("constructBootClassPath()");
+    addedToBootCP.clear();
+    addedToCP.clear();
+    classPath = cpBefore;
+
+    string jruby_complete_jar = platformDir + FILE_SEP + "lib" + FILE_SEP + "jruby-complete.jar";
+    string jruby_jar = platformDir + FILE_SEP + "lib" + FILE_SEP + "jruby.jar";
+
+    if (fileExists(jruby_jar.c_str())) {
+      addToBootClassPath(jruby_jar.c_str(), true);
+      if (fileExists(jruby_complete_jar.c_str())) {
+          printToConsole("WARNING: Both jruby-complete.jar and jruby.jar are present in the 'lib' directory. Will use jruby.jar\n");
+      }
+    } else if (fileExists(jruby_complete_jar.c_str())) {
+        addToBootClassPath(jruby_complete_jar.c_str());
+    }
+
+    logMsg("BootclassPath: %s", bootClassPath.c_str());
+}
+
+void ArgParser::constructClassPath() {
+    logMsg("constructClassPath()");
+
+    addJarsToClassPathFrom(platformDir.c_str());
+
+    if (cpExplicit.empty()) {
+        logMsg("No explicit classpath option is used, looking up %%CLASSPATH%% env");
+        char *envCP = getenv("CLASSPATH");
+        if (envCP) {
+            addToClassPath(envCP, false);
+        }
+    } else {
+        logMsg("Explicit classpath option is used, ignoring %%CLASSPATH%% env");
+        addToClassPath(cpExplicit.c_str(), false);
+    }
+
+    if (!cpAfter.empty()) {
+        classPath += PATH_SEP;
+        classPath += cpAfter;
+    }
+
+    logMsg("ClassPath: %s", classPath.c_str());
+}
+
+void ArgParser::addJarsToClassPathFrom(const char *dir) {
+    logMsg("addJarsToClassPathFrom()\n\tdir: %s", dir);
+    string path = dir;
+    path += FILE_SEP;
+    path += "lib";
+
+#ifdef WIN32
+    WIN32_FIND_DATA fd = {0};
+    string patternPath = path + FILE_SEP + "*.jar";
+    HANDLE hFind = FindFirstFile(patternPath.c_str(), &fd);
+    if (hFind == INVALID_HANDLE_VALUE) {
+        logMsg("Nothing found (%s)", patternPath.c_str());
+        return;
+    }
+    do {
+        string fullName = path + FILE_SEP + fd.cFileName;
+        addToClassPath(fullName.c_str());
+    } while (FindNextFile(hFind, &fd));
+    FindClose(hFind);
+#else
+    DIR *directory = opendir(path.c_str());
+    if (!directory) {
+        logMsg("Nothing found (%s)", path.c_str());
+        return;
+    }
+
+    struct dirent *ent;
+    while((ent = readdir(directory)) != NULL) {
+        int len = strlen(ent->d_name);
+        if (len > 4 && strncmp(".jar", (ent->d_name + (len - 4)), 4) == 0) {
+            string fullName = path + FILE_SEP + ent->d_name;
+            addToClassPath(fullName.c_str());
+        }
+    }
+    closedir(directory);
+#endif
+}
+
+void ArgParser::addToClassPath(const char *path, bool onlyIfExists) {
+    logMsg("addToClassPath()\n\tpath: %s\n\tonlyIfExists: %s", path, onlyIfExists ? "true" : "false");
+    if (onlyIfExists && !fileExists(path)) {
+        return;
+    }
+
+    if (!addedToCP.insert(path).second) {
+        logMsg("\"%s\" already added, skipping", path);
+        return;
+    }
+
+    // check that this hasn't been added to boot class path already
+    if (addedToBootCP.find(path) == addedToBootCP.end()) {
+        if (!classPath.empty()) {
+            classPath += PATH_SEP;
+        }
+        classPath += path;
+    } else {
+        logMsg("No need to add \"%s\" to classpath, it's already in bootclasspath", path);
+    }
+}
+
+void ArgParser::addToBootClassPath(const char *path, bool onlyIfExists) {
+    logMsg("addToBootClassPath()\n\tpath: %s\n\tonlyIfExists: %s", path, onlyIfExists ? "true" : "false");
+
+    if (nailgunServer) {
+        logMsg("NOTE: In 'ng-server' mode there is no bootclasspath, adding to classpath...");
+        return addToClassPath(path, onlyIfExists);
+    }
+
+    if (onlyIfExists && !fileExists(path)) {
+        return;
+    }
+
+    // only add non-duplicates
+    if (addedToBootCP.insert(path).second) {
+        if (!bootClassPath.empty()) {
+            bootClassPath += PATH_SEP;
+        }
+        bootClassPath += path;
+    } else {
+        logMsg("\"%s\" already in bootclasspath", path);
+    }
+}
+
+void ArgParser::appendToHelp(const char *msg) {
+    if (msg) {
+        appendHelp = msg;
+    }
+}
+
+void ArgParser::addOptionsToCommandLine(list<string> & commandLine) {
+    commandLine.insert(commandLine.end(), javaOptions.begin(), javaOptions.end());
+    commandLine.insert(commandLine.end(), bootclass);
+    commandLine.insert(commandLine.end(), progArgs.begin(), progArgs.end());
+}