SPECjvm2008, uses the Thread.getContextClassLoader() class loader
to load classes - instead of using the current class-loader as any
decent code does when using reflection.

To allow this ugly, but officially supported, usage, we need to
set the context class loader in RunJar.java.

eventually causing a suspicious segfault.

class-static variable, which is not only strange, it also means we
cannot concurrently run several programs in several threads.

Change it so run() returns the (32-bit) return value, and when execution
fails (e.g., file not found), it throws an IOException.

Note that unlike Unix where main()'s return value is limited to 8 bits,
here we decided to allow the full gamut (63-bit) of return values from
main(). main() may return -23 or 2323813 and this does not indicate
an error running it (only an exception indicates an error).

This patch also removes the arbitrary limit of 256 command line arguments
(not that anyone would need more...).

All Java tests need to implement the Test interface and be registered with
TestRunner in order to be available to the test cli command.

TCPEchoServerTest is no longer accessible from javascript, instead, TestRunner is
now the interface of JS for running tests.

note: this class is not yet used by the CLI and will be used in a following
patch

split cloudius.jar to cloudius.jar an cli.jar
the following patch will introduce proper code reusing between the two jars
basically, cli.jar will be dependant on cloudius.jar

we're about to split cloudius.jar into 2 jars:
1. cloudius.jar - holds various utils and interfacing jni
2. cli.jar - wrappers needed for the cli, commuication of js<->java

per Nadav suggestion.

from javascript.

it translate the arguments recieved from javascript, invokes the jni method
and return the exit code to javascript

expects to recieve a String[] array as an argument, invokes run_elf()
and communicates the return value by setting a static int of the invoking
class

other classes may need to read/write global javascript objects, the run
command which is going to be commited in the next patch deals with it

the test creates 2 threads, a client and a server,
server is echoing back message received from the client.

this test extends ScriptableObject, which means it can be accessible
in the scope of rhino.

cloudius.jar's main entry point embeds rhino and execute cli.js

instead of running rhino.jar -f <file>, we now embed rhino within our own class
and completely control the context of the script engine.

reuse Global() from org.mozilla.javascript.tools.shell to initialize
our Context, this is done so we'll have functions such as importPackage()
available to Javascript.

this patch still doesn't replace rhino shell.

Added build ("make") framework for compiling Java code we want to run in
OSv (in/with the Java payload), as well as JNI, i.e., OSv-specific C code
we want to run from the above Java code.

The Java source files in java/src/ are now all compiled during build
(see java/build.xml for the Ant file doing this compilation) and the
result is one JAR, build/$mode/java/cloudius.jar (/cloudius.jar in bootfs).
We can easily change build.xml to create more than one if we want.

As an example of JNI, I used the not-working-yet balloon feature.
java/src/com/cloudius/balloon/Balloon.java is the class
com.cloudius.balloon.Balloon which is supposed to have one "native"
(implemented in C) function giveup(). This function's implementation is
in java/jni/balloon.c. We get this file to compile to balloon.so (put
in /usr/lib/jni in the bootfs) by adding java/jni/balloon.so to the
"jni" list in build.mak.

If you don't know how write the ugly function signature as seen in
java/jni/balloon.c, you can run "javah com.cloudius.balloon.Balloon"
to build the empty functions needed for implementing the native functions
defined in the above class.

This allows running either testrunner.so, or one of the tests (e.g.
test/tst-fpu.so), as they now both export the same entry point.

Allows seeing UnsatisfiedLinkErrors while loading jars.

-jar terminates the JVM arguments, so that 'java -jar foo.jar -x' passes
-x to foo.jar, not the JVM.

A silly error causes a crash whenever arguments to the Java class are
supplied.

This will allow running unmodified tests with a main() entry point even
after splitting the test loader out of the kernel.