Index: src/org/jruby/runtime/ReadonlyGlobalVariable.java
===================================================================
--- src/org/jruby/runtime/ReadonlyGlobalVariable.java	(revision 8091)
+++ src/org/jruby/runtime/ReadonlyGlobalVariable.java	(working copy)
@@ -34,12 +34,12 @@
 
 public class ReadonlyGlobalVariable extends GlobalVariable {
 
-    public ReadonlyGlobalVariable(Ruby runtime, String name, IRubyObject value) {
-        super(runtime, name, value);
+    public ReadonlyGlobalVariable(String name, IRubyObject value) {
+        super(name, value);
     }
 
     @Override
     public IRubyObject set(IRubyObject value) {
-        throw runtime.newNameError(name() + " is a read-only variable", name());
+        throw Ruby.getCurrentRuntime().newNameError(name() + " is a read-only variable", name());
     }
 }
Index: src/org/jruby/runtime/GlobalVariable.java
===================================================================
--- src/org/jruby/runtime/GlobalVariable.java	(revision 8091)
+++ src/org/jruby/runtime/GlobalVariable.java	(working copy)
@@ -39,7 +39,7 @@
         private GlobalVariable other;
 
         public Copy(Ruby runtime, String name, GlobalVariable other) {
-            super(runtime, name, other.get());
+            super(name, other.get());
             this.other = other;
         }
 
@@ -54,8 +54,6 @@
         }
     }
 
-    protected final Ruby runtime;
-
     protected final String name;
     private IRubyObject value;
 
@@ -63,10 +61,8 @@
         return "$" + name;
     }
 
-    public GlobalVariable(Ruby runtime, String name, IRubyObject value) {
+    public GlobalVariable(String name, IRubyObject value) {
         assert name.startsWith("$");
-
-        this.runtime = runtime;
         this.name = name;
         this.value = value;
     }
Index: src/org/jruby/runtime/GlobalVariableAcessor.java
===================================================================
--- src/org/jruby/runtime/GlobalVariableAcessor.java	(revision 0)
+++ src/org/jruby/runtime/GlobalVariableAcessor.java	(revision 0)
@@ -0,0 +1,24 @@
+package org.jruby.runtime;
+
+import org.jruby.runtime.IAccessor;
+import org.jruby.runtime.GlobalVariable;
+import org.jruby.runtime.builtin.IRubyObject;
+
+/**
+ * @author Fabio Kung
+*/
+public class GlobalVariableAcessor implements IAccessor {
+    private final GlobalVariable variable;
+
+    public GlobalVariableAcessor(GlobalVariable variable) {
+        this.variable = variable;
+    }
+
+    public IRubyObject getValue() {
+        return variable.get();
+    }
+
+    public IRubyObject setValue(IRubyObject newValue) {
+        return variable.set(newValue);
+    }
+}
Index: src/org/jruby/ext/ffi/io/FileDescriptorIO.java
===================================================================
--- src/org/jruby/ext/ffi/io/FileDescriptorIO.java	(revision 8091)
+++ src/org/jruby/ext/ffi/io/FileDescriptorIO.java	(working copy)
@@ -68,7 +68,7 @@
         } catch (InvalidValueException ex) {
             throw new RuntimeException(ex);
         }
-        openFile.setMainStream(new ChannelStream(getRuntime(),
+        openFile.setMainStream(new ChannelStream(
                 new ChannelDescriptor(Factory.getInstance().newByteChannel(RubyNumeric.fix2int(fd)),
                 getNewFileno(), modes, new java.io.FileDescriptor())));
         openFile.setPipeStream(openFile.getMainStream());
Index: src/org/jruby/ext/socket/RubyUNIXSocket.java
===================================================================
--- src/org/jruby/ext/socket/RubyUNIXSocket.java	(revision 8091)
+++ src/org/jruby/ext/socket/RubyUNIXSocket.java	(working copy)
@@ -311,7 +311,7 @@
 
     protected void init_sock(Ruby runtime) throws Exception {
         ModeFlags modes = new ModeFlags(ModeFlags.RDWR);
-        openFile.setMainStream(new ChannelStream(runtime, new ChannelDescriptor(new UnixDomainSocketChannel(fd), getNewFileno(), modes, new java.io.FileDescriptor())));
+        openFile.setMainStream(new ChannelStream(new ChannelDescriptor(new UnixDomainSocketChannel(fd), getNewFileno(), modes, new java.io.FileDescriptor())));
         openFile.setPipeStream(openFile.getMainStream());
         openFile.setMode(modes.getOpenFileFlags());
         openFile.getMainStream().setSync(true);
Index: src/org/jruby/internal/runtime/GlobalVariables.java
===================================================================
--- src/org/jruby/internal/runtime/GlobalVariables.java	(revision 8091)
+++ src/org/jruby/internal/runtime/GlobalVariables.java	(working copy)
@@ -47,13 +47,8 @@
  * @author jpetersen
  */
 public class GlobalVariables {
-    private Ruby runtime;
     private Map<String, GlobalVariable> globalVariables = new ConcurrentHashMap<String, GlobalVariable>();
 
-    public GlobalVariables(Ruby runtime) {
-        this.runtime = runtime;
-    }
-
     public void define(String name, IAccessor accessor) {
         assert name != null;
         assert accessor != null;
@@ -89,15 +84,16 @@
         assert name.startsWith("$");
         assert oldName.startsWith("$");
 
-        if (runtime.getSafeLevel() >= 4) {
-            throw runtime.newSecurityError("Insecure: can't alias global variable");
+        if (Ruby.getCurrentRuntime().getSafeLevel() >= 4) {
+            throw Ruby.getCurrentRuntime().newSecurityError("Insecure: can't alias global variable");
         }
 
         GlobalVariable oldVariable = createIfNotDefined(oldName);
         GlobalVariable variable = (GlobalVariable)globalVariables.get(name);
 
         if (variable != null && oldVariable != variable && variable.isTracing()) {
-            throw new RaiseException(runtime, runtime.getRuntimeError(), "can't alias in tracer", false);
+            throw new RaiseException(Ruby.getCurrentRuntime(), Ruby.getCurrentRuntime().getRuntimeError(),
+                    "can't alias in tracer", false);
         }
 
         globalVariables.put(name, oldVariable);
@@ -111,16 +107,16 @@
 	    if (variable != null) {
 	        return variable.getAccessor().getValue();
 	    }
-		runtime.getWarnings().warning(ID.GLOBAL_NOT_INITIALIZED, "global variable `" + name + "' not initialized", name);
-		return runtime.getNil();
+		Ruby.getCurrentRuntime().getWarnings().warning(ID.GLOBAL_NOT_INITIALIZED, "global variable `" + name + "' not initialized", name);
+		return Ruby.getCurrentRuntime().getNil();
 	}
 
     public IRubyObject set(String name, IRubyObject value) {
         assert name != null;
         assert name.startsWith("$");
 
-        if (runtime.getSafeLevel() >= 4) {
-            throw runtime.newSecurityError("Insecure: can't change global variable value");
+        if (Ruby.getCurrentRuntime().getSafeLevel() >= 4) {
+            throw Ruby.getCurrentRuntime().newSecurityError("Insecure: can't change global variable value");
         }
 
         GlobalVariable variable = createIfNotDefined(name);
@@ -165,7 +161,7 @@
     private GlobalVariable createIfNotDefined(String name) {
         GlobalVariable variable = (GlobalVariable)globalVariables.get(name);
         if (variable == null) {
-            variable = GlobalVariable.newUndefined(runtime, name);
+            variable = GlobalVariable.newUndefined(Ruby.getCurrentRuntime(), name);
             globalVariables.put(name, variable);
         }
         return variable;
Index: src/org/jruby/internal/runtime/RuntimeVariableAccessor.java
===================================================================
--- src/org/jruby/internal/runtime/RuntimeVariableAccessor.java	(revision 0)
+++ src/org/jruby/internal/runtime/RuntimeVariableAccessor.java	(revision 0)
@@ -0,0 +1,32 @@
+package org.jruby.internal.runtime;
+
+import org.jruby.runtime.IAccessor;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.Ruby;
+
+/**
+ * @author Fabio Kung
+ */
+public class RuntimeVariableAccessor implements IAccessor {
+    private final String name;
+
+    public RuntimeVariableAccessor(String name) {
+        this.name = name;
+    }
+
+    public RuntimeVariableAccessor(String name, IRubyObject value) {
+        this.name = name;
+        setValue(value);
+    }
+
+    public IRubyObject getValue() {
+        Ruby runtime = Ruby.getCurrentRuntime();
+        return runtime.getRuntimeVariable(this.name);
+    }
+
+    public IRubyObject setValue(IRubyObject newValue) {
+        Ruby runtime = Ruby.getCurrentRuntime();
+        runtime.setRuntimeVariable(this.name, newValue);
+        return newValue;
+    }
+}
Index: src/org/jruby/RubyArgsFile.java
===================================================================
--- src/org/jruby/RubyArgsFile.java	(revision 8091)
+++ src/org/jruby/RubyArgsFile.java	(working copy)
@@ -39,6 +39,7 @@
 import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.builtin.IRubyObject;
 import org.jruby.util.ByteList;
+import org.jruby.internal.runtime.RuntimeVariableAccessor;
 
 public class RubyArgsFile {
     private static final class ArgsFileData {
@@ -106,12 +107,13 @@
 
         runtime.getEnumerable().extend_object(argsFile);
         
-        runtime.defineReadonlyVariable("$<", argsFile);
+        runtime.getGlobalVariables().defineReadonly("$<", new RuntimeVariableAccessor("$<", argsFile));
         runtime.defineGlobalConstant("ARGF", argsFile);
         
         RubyClass argfClass = argsFile.getMetaClass();
         argfClass.defineAnnotatedMethods(RubyArgsFile.class);
-        runtime.defineReadonlyVariable("$FILENAME", runtime.newString("-"));
+        runtime.getGlobalVariables().defineReadonly("$FILENAME",
+                new RuntimeVariableAccessor("$FILENAME", runtime.newString("-")));
     }
 
     @JRubyMethod(name = {"fileno", "to_i"})
Index: src/org/jruby/RubyFile.java
===================================================================
--- src/org/jruby/RubyFile.java	(revision 8091)
+++ src/org/jruby/RubyFile.java	(working copy)
@@ -165,7 +165,7 @@
         super(runtime, runtime.getFile());
         this.path = path;
         try {
-            this.openFile.setMainStream(new ChannelStream(runtime, new ChannelDescriptor(Channels.newChannel(in), getNewFileno(), new FileDescriptor())));
+            this.openFile.setMainStream(new ChannelStream(new ChannelDescriptor(Channels.newChannel(in), getNewFileno(), new FileDescriptor())));
         } catch (InvalidValueException ex) {
             throw runtime.newErrnoEINVALError();
         }
Index: src/org/jruby/Ruby.java
===================================================================
--- src/org/jruby/Ruby.java	(revision 8091)
+++ src/org/jruby/Ruby.java	(working copy)
@@ -110,6 +110,7 @@
 import org.jruby.runtime.ObjectSpace;
 import org.jruby.runtime.RubyEvent;
 import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.GlobalVariableAcessor;
 import org.jruby.runtime.builtin.IRubyObject;
 import org.jruby.runtime.encoding.EncodingService;
 import org.jruby.runtime.load.Library;
@@ -122,6 +123,7 @@
 import org.jruby.util.JRubyClassLoader;
 import org.jruby.util.JavaNameMangler;
 import org.jruby.util.KCode;
+import org.jruby.util.RuntimeContainer;
 import org.jruby.util.SafePropertyAccessor;
 import org.jruby.util.collections.WeakHashSet;
 import org.jruby.util.io.ChannelDescriptor;
@@ -136,7 +138,7 @@
  * multiple instances of each class. This means that in multi-runtime mode
  * (or really, multi-VM mode, where each JRuby instance is a ruby "VM"), objects
  * generally can't be transported across runtimes without marshaling.
- * 
+ *
  * This class roots everything that makes the JRuby runtime function, and
  * provides a number of utility methods for constructing global types and
  * accessing global runtime structures.
@@ -183,16 +185,27 @@
         config.setError(err);
         return newInstance(config);
     }
-    
+
+    public static Ruby getCurrentRuntime() {
+        JRubyClassLoader loader = (JRubyClassLoader) Thread.currentThread().getContextClassLoader();
+        while (!(loader instanceof RuntimeContainer)) {
+            loader = (JRubyClassLoader) loader.getParent();
+        }
+        return ((RuntimeContainer) loader).getRuntime();
+    }
+
     /**
      * Create and initialize a new JRuby runtime. The properties of the
      * specified RubyInstanceConfig will be used to determine various JRuby
      * runtime characteristics.
-     * 
+     *
      * @param config The configuration to use for the new instance
      * @see org.jruby.RubyInstanceConfig
      */
     private Ruby(RubyInstanceConfig config) {
+        Thread currentThread = Thread.currentThread();
+        currentThread.setContextClassLoader(new RuntimeContainer(currentThread.getContextClassLoader(), this));
+
         this.config             = config;
         this.threadService      = new ThreadService(this);
         if(config.isSamplingEnabled()) {
@@ -209,18 +222,18 @@
         this.beanManager        = new BeanManager(this, config.isManagementEnabled());
         this.jitCompiler        = new JITCompiler(this);
         this.parserStats        = new ParserStats(this);
-        
+
         this.beanManager.register(new Config(this));
         this.beanManager.register(parserStats);
         this.beanManager.register(new ClassCache(this));
     }
-    
+
     /**
      * Evaluates a script under the current scope (perhaps the top-level
      * scope) and returns the result (generally the last value calculated).
      * This version goes straight into the interpreter, bypassing compilation
      * and runtime preparation typical to normal script runs.
-     * 
+     *
      * @param script The scriptlet to run
      * @returns The result of the eval
      */
@@ -229,7 +242,7 @@
         DynamicScope currentScope = context.getCurrentScope();
         ManyVarsDynamicScope newScope = new ManyVarsDynamicScope(new EvalStaticScope(currentScope.getStaticScope()), currentScope);
         Node node = parseEval(script, "<script>", newScope, 0);
-        
+
         try {
             context.preEvalScriptlet(newScope);
             return node.interpret(this, context, context.getFrameSelf(), Block.NULL_BLOCK);
@@ -243,20 +256,20 @@
             context.postEvalScriptlet();
         }
     }
-    
+
     /**
-     * Parse and execute the specified script 
+     * Parse and execute the specified script
      * This differs from the other methods in that it accepts a string-based script and
      * parses and runs it as though it were loaded at a command-line. This is the preferred
      * way to start up a new script when calling directly into the Ruby object (which is
      * generally *dis*couraged.
-     * 
+     *
      * @param script The contents of the script to run as a normal, root script
      * @return The last value of the script
      */
     public IRubyObject executeScript(String script, String filename) {
         byte[] bytes;
-        
+
         try {
             bytes = script.getBytes(KCode.NONE.getKCode());
         } catch (UnsupportedEncodingException e) {
@@ -265,7 +278,7 @@
 
         Node node = parseInline(new ByteArrayInputStream(bytes), filename, null);
         ThreadContext context = getCurrentContext();
-        
+
         String oldFile = context.getFile();
         int oldLine = context.getLine();
         try {
@@ -277,22 +290,22 @@
             context.setLine(oldLine);
         }
     }
-    
+
     /**
      * Run the script contained in the specified input stream, using the
      * specified filename as the name of the script being executed. The stream
      * will be read fully before being parsed and executed. The given filename
      * will be used for the ruby $PROGRAM_NAME and $0 global variables in this
      * runtime.
-     * 
+     *
      * This method is intended to be called once per runtime, generally from
      * Main or from main-like top-level entry points.
-     * 
+     *
      * As part of executing the script loaded from the input stream, various
      * RubyInstanceConfig properties will be used to determine whether to
      * compile the script before execution or run with various wrappers (for
      * looping, printing, and so on, see jruby -help).
-     * 
+     *
      * @param inputStream The InputStream from which to read the script contents
      * @param filename The filename to use when parsing, and for $PROGRAM_NAME
      * and $0 ruby global variables.
@@ -314,7 +327,7 @@
             getGlobalVariables().set("$" + entry.getKey().toString(), varvalue);
         }
 
-        
+
         if(config.isYARVEnabled()) {
             if (config.isShowBytecode()) System.err.print("error: bytecode printing only works with JVM bytecode");
             new YARVCompiledRunner(this, inputStream, filename).run();
@@ -350,7 +363,7 @@
      * is used to verify that the script syntax is valid, for jruby -c. The
      * current scope (generally the top-level scope) is used as the parent
      * scope for parsing.
-     * 
+     *
      * @param inputStream The input stream from which to read the script
      * @param filename The filename to use for parsing
      * @returns The root node of the parsed script
@@ -362,12 +375,12 @@
             return parseFile(inputStream, filename, getCurrentContext().getCurrentScope());
         }
     }
-    
+
     /**
      * Run the given script with a "while gets; end" loop wrapped around it.
      * This is primarily used for the -n command-line flag, to allow writing
      * a short script that processes input lines using the specified code.
-     * 
+     *
      * @param scriptNode The root node of the script to execute
      * @param printing Whether $_ should be printed after each loop (as in the
      * -p command-line flag)
@@ -380,7 +393,7 @@
      */
     public IRubyObject runWithGetsLoop(Node scriptNode, boolean printing, boolean processLineEnds, boolean split, boolean yarvCompile) {
         ThreadContext context = getCurrentContext();
-        
+
         Script script = null;
         YARVCompiledRunner runner = null;
         boolean compile = getInstanceConfig().getCompileMode().shouldPrecompileCLI();
@@ -393,22 +406,22 @@
         } else if (yarvCompile) {
             runner = tryCompileYarv(scriptNode);
         }
-        
+
         if (processLineEnds) {
             getGlobalVariables().set("$\\", getGlobalVariables().get("$/"));
         }
-        
+
         while (RubyKernel.gets(context, getTopSelf(), IRubyObject.NULL_ARRAY).isTrue()) {
             loop: while (true) { // Used for the 'redo' command
                 try {
                     if (processLineEnds) {
                         getGlobalVariables().get("$_").callMethod(context, "chop!");
                     }
-                    
+
                     if (split) {
                         getGlobalVariables().set("$F", getGlobalVariables().get("$_").callMethod(context, "split"));
                     }
-                    
+
                     if (script != null) {
                         runScript(script);
                     } else if (runner != null) {
@@ -416,7 +429,7 @@
                     } else {
                         runInterpreter(scriptNode);
                     }
-                    
+
                     if (printing) RubyKernel.print(context, getKernel(), new IRubyObject[] {getGlobalVariables().get("$_")});
                     break loop;
                 } catch (JumpException.RedoJump rj) {
@@ -430,14 +443,14 @@
                 }
             }
         }
-        
+
         return getNil();
     }
-    
+
     /**
      * Run the specified script without any of the loop-processing wrapper
      * code.
-     * 
+     *
      * @param scriptNode The root node of the script to be executed
      * @param yarvCompile Whether to compile the script to YARV (Ruby 1.9)
      * bytecode before execution
@@ -456,7 +469,7 @@
                 return getNil();
             }
         }
-        
+
         if (script != null) {
             if (config.isShowBytecode()) {
                 return nilObject;
@@ -470,11 +483,11 @@
             return runInterpreter(scriptNode);
         }
     }
-    
+
     private Script tryCompile(Node node) {
         return tryCompile(node, new JRubyClassLoader(getJRubyClassLoader()));
     }
-    
+
     private Script tryCompile(Node node, JRubyClassLoader classLoader) {
         Script script = null;
         try {
@@ -533,10 +546,10 @@
                 System.err.println("Error, could not compile; pass -d or -J-Djruby.jit.logging.verbose=true for more details");
             }
         }
-        
+
         return script;
     }
-    
+
     private YARVCompiledRunner tryCompileYarv(Node node) {
         try {
             StandardYARVCompiler compiler = new StandardYARVCompiler(this);
@@ -553,17 +566,17 @@
             return null;
         }
     }
-    
+
     private IRubyObject runScript(Script script) {
         ThreadContext context = getCurrentContext();
-        
+
         try {
             return script.load(context, context.getFrameSelf(), IRubyObject.NULL_ARRAY, Block.NULL_BLOCK);
         } catch (JumpException.ReturnJump rj) {
             return (IRubyObject) rj.getValue();
         }
     }
-    
+
     private IRubyObject runYarv(YARVCompiledRunner runner) {
         try {
             return runner.run();
@@ -571,12 +584,12 @@
             return (IRubyObject) rj.getValue();
         }
     }
-    
+
     private IRubyObject runInterpreter(Node scriptNode) {
         ThreadContext context = getCurrentContext();
-        
+
         assert scriptNode != null : "scriptNode is not null";
-        
+
         try {
             return scriptNode.interpret(this, context, getTopSelf(), Block.NULL_BLOCK);
         } catch (JumpException.ReturnJump rj) {
@@ -587,11 +600,11 @@
     public Parser getParser() {
         return parser;
     }
-    
+
     public BeanManager getBeanManager() {
         return beanManager;
     }
-    
+
     public JITCompiler getJITCompiler() {
         return jitCompiler;
     }
@@ -602,16 +615,16 @@
     public static Ruby getDefaultInstance() {
         return newInstance();
     }
-    
+
     @Deprecated
     public static Ruby getCurrentInstance() {
         return null;
     }
-    
+
     @Deprecated
     public static void setCurrentInstance(Ruby runtime) {
     }
-    
+
     public int allocSymbolId() {
         return symbolLastId.incrementAndGet();
     }
@@ -621,7 +634,7 @@
 
     /**
      * Retrieve the module with the given name from the Object namespace.
-     * 
+     *
      * @param name The name of the module
      * @return The module or null if not found
      */
@@ -633,7 +646,7 @@
      * Retrieve the module with the given name from the Object namespace. The
      * module name must be an interned string, but this method will be faster
      * than the non-interned version.
-     * 
+     *
      * @param internedName The name of the module; <em>must</em> be an interned String
      * @return The module or null if not found
      */
@@ -641,7 +654,7 @@
         return (RubyModule) objectClass.fastGetConstantAt(internedName);
     }
 
-    /** 
+    /**
      * Retrieve the class with the given name from the Object namespace.
      *
      * @param name The name of the class
@@ -655,7 +668,7 @@
      * Retrieve the class with the given name from the Object namespace. The
      * module name must be an interned string, but this method will be faster
      * than the non-interned version.
-     * 
+     *
      * @param internedName the name of the class; <em>must</em> be an interned String!
      * @return
      */
@@ -663,7 +676,7 @@
         return objectClass.fastGetClass(internedName);
     }
 
-    /** 
+    /**
      * Define a new class under the Object namespace. Roughly equivalent to
      * rb_define_class in MRI.
      *
@@ -677,7 +690,7 @@
         return defineClassUnder(name, superClass, allocator, objectClass);
     }
 
-    /** 
+    /**
      * A variation of defineClass that allows passing in an array of subplementary
      * call sites for improving dynamic invocation performance.
      *
@@ -694,7 +707,7 @@
     /**
      * Define a new class with the given name under the given module or class
      * namespace. Roughly equivalent to rb_define_class_under in MRI.
-     * 
+     *
      * If the name specified is already bound, its value will be returned if:
      * * It is a class
      * * No new superclass is being defined
@@ -738,23 +751,23 @@
             }
             return klazz;
         }
-        
+
         boolean parentIsObject = parent == objectClass;
 
         if (superClass == null) {
-            String className = parentIsObject ? name : parent.getName() + "::" + name;  
+            String className = parentIsObject ? name : parent.getName() + "::" + name;
             warnings.warn(ID.NO_SUPER_CLASS, "no super class for `" + className + "', Object assumed", className);
-            
+
             superClass = objectClass;
         }
 
         return RubyClass.newClass(this, superClass, name, allocator, parent, !parentIsObject, callSites);
     }
 
-    /** 
+    /**
      * Define a new module under the Object namespace. Roughly equivalent to
      * rb_define_module in MRI.
-     * 
+     *
      * @param name The name of the new module
      * @returns The new module
      */
@@ -765,7 +778,7 @@
     /**
      * Define a new module with the given name under the given module or
      * class namespace. Roughly equivalent to rb_define_module_under in MRI.
-     * 
+     *
      * @param name The name of the new module
      * @param parent The class or module namespace under which to define the
      * module
@@ -773,12 +786,12 @@
      */
     public RubyModule defineModuleUnder(String name, RubyModule parent) {
         IRubyObject moduleObj = parent.getConstantAt(name);
-        
+
         boolean parentIsObject = parent == objectClass;
 
         if (moduleObj != null ) {
             if (moduleObj.isModule()) return (RubyModule)moduleObj;
-            
+
             if (parentIsObject) {
                 throw newTypeError(moduleObj.getMetaClass().getName() + " is not a module");
             } else {
@@ -792,7 +805,7 @@
     /**
      * From Object, retrieve the named module. If it doesn't exist a
      * new module is created.
-     * 
+     *
      * @param name The name of the module
      * @returns The existing or new module
      */
@@ -810,9 +823,9 @@
     }
 
 
-    /** 
+    /**
      * Retrieve the current safe level.
-     * 
+     *
      * @see org.jruby.Ruby#setSaveLevel
      */
     public int getSafeLevel() {
@@ -820,15 +833,15 @@
     }
 
 
-    /** 
+    /**
      * Set the current safe level:
-     * 
+     *
      * 0 - strings from streams/environment/ARGV are tainted (default)
      * 1 - no dangerous operation by tainted value
      * 2 - process/file operations prohibited
      * 3 - all generated objects are tainted
      * 4 - no global (non-tainted) variable modification/no direct output
-     * 
+     *
      * The safe level is set using $SAFE in Ruby code. It is not particularly
      * well supported in JRuby.
     */
@@ -877,7 +890,7 @@
     public boolean isClassDefined(String name) {
         return getModule(name) != null;
     }
-    
+
     /**
      * A ThreadFactory for when we're using pooled threads; we want to create
      * the threads with daemon = true so they don't keep us from shutting down.
@@ -886,12 +899,12 @@
         public Thread newThread(Runnable runnable) {
             Thread thread = new Thread(runnable);
             thread.setDaemon(true);
-            
+
             return thread;
         }
     }
 
-    /** 
+    /**
      * This method is called immediately after constructing the Ruby instance.
      * The main thread is prepared for execution, all core classes and libraries
      * are initialized, and any libraries required on the command line are
@@ -902,12 +915,12 @@
         ThreadContext tc = getCurrentContext();
 
         safeLevel = config.getSafeLevel();
-        
+
         // Construct key services
         loadService = config.createLoadService(this);
         posix = POSIXFactory.getPOSIX(new JRubyPOSIXHandler(this), RubyInstanceConfig.nativeEnabled);
         javaSupport = new JavaSupport(this);
-        
+
         if (RubyInstanceConfig.POOLING_ENABLED) {
             Executors.newCachedThreadPool();
             executor = new ThreadPoolExecutor(
@@ -918,7 +931,7 @@
                     new SynchronousQueue<Runnable>(),
                     new DaemonThreadFactory());
         }
-        
+
         // initialize the root of the class hierarchy completely
         initRoot();
 
@@ -927,11 +940,11 @@
 
         // Initialize all the core classes
         bootstrap();
-        
+
         // Initialize the "dummy" class used as a marker
         dummyClass = new RubyClass(this, classClass);
         dummyClass.freeze(tc);
-        
+
         // Create global constants and variables
         RubyGlobal.createGlobals(tc, this);
 
@@ -940,7 +953,7 @@
 
         // initialize builtin libraries
         initBuiltins();
-        
+
         // Require in all libraries specified on command line
         for (String scriptName : config.requiredLibraries()) {
             RubyKernel.require(getTopSelf(), newString(scriptName), Block.NULL_BLOCK);
@@ -969,8 +982,8 @@
 
         RubyObject.createObjectClass(this, objectClass);
         RubyModule.createModuleClass(this, moduleClass);
-        RubyClass.createClassClass(this, classClass);
-        
+        RubyClass.createClassClass(classClass);
+
         // set constants now that they're initialized
         objectClass.setConstant("Object", objectClass);
         objectClass.setConstant("Class", classClass);
@@ -1144,10 +1157,10 @@
         scriptError = defineClassIfAllowed("ScriptError", exceptionClass);
         rangeError = defineClassIfAllowed("RangeError", standardError);
         signalException = defineClassIfAllowed("SignalException", exceptionClass);
-        
+
         if (profile.allowClass("NameError")) {
             nameError = RubyNameError.createNameErrorClass(this, standardError);
-            nameErrorMessage = RubyNameError.createNameErrorMessageClass(this, nameError);            
+            nameErrorMessage = RubyNameError.createNameErrorMessageClass(this, nameError);
         }
         if (profile.allowClass("NoMethodError")) {
             noMethodError = RubyNoMethodError.createNoMethodErrorClass(this, nameError);
@@ -1185,14 +1198,14 @@
 
         if (config.getCompatVersion() == CompatVersion.RUBY1_9) {
             if (profile.allowClass("EncodingError")) {
-                encodingError = defineClass("EncodingError", standardError, standardError.getAllocator()); 
+                encodingError = defineClass("EncodingError", standardError, standardError.getAllocator());
                 encodingCompatibilityError = defineClassUnder("CompatibilityError", encodingError, encodingError.getAllocator(), encodingClass);
             }
         }
 
         initErrno();
     }
-    
+
     private RubyClass defineClassIfAllowed(String name, RubyClass superClass) {
 	// TODO: should probably apply the null object pattern for a
 	// non-allowed class, rather than null
@@ -1237,9 +1250,9 @@
     private void initBuiltins() {
         addLazyBuiltin("java.rb", "java", "org.jruby.javasupport.Java");
         addLazyBuiltin("jruby.rb", "jruby", "org.jruby.libraries.JRubyLibrary");
-        
+
         addLazyBuiltin("minijava.rb", "minijava", "org.jruby.java.MiniJava");
-        
+
         addLazyBuiltin("jruby/ext.rb", "jruby/ext", "org.jruby.RubyJRuby$ExtLibrary");
         addLazyBuiltin("jruby/core_ext.rb", "jruby/ext", "org.jruby.RubyJRuby$CoreExtLibrary");
         addLazyBuiltin("jruby/type.rb", "jruby/type", "org.jruby.RubyJRuby$TypeLibrary");
@@ -1270,22 +1283,22 @@
         if(RubyInstanceConfig.NATIVE_NET_PROTOCOL) {
             addLazyBuiltin("net/protocol.rb", "net/protocol", "org.jruby.libraries.NetProtocolBufferedIOLibrary");
         }
-        
+
         if (config.getCompatVersion() == CompatVersion.RUBY1_9) {
             addLazyBuiltin("fiber.so", "fiber", "org.jruby.libraries.FiberLibrary");
         }
-        
+
         addBuiltinIfAllowed("openssl.so", new Library() {
             public void load(Ruby runtime, boolean wrap) throws IOException {
                 runtime.getLoadService().require("jruby/openssl/stub");
             }
         });
-        
+
         String[] builtins = {"fcntl", "yaml", "yaml/syck", "jsignal" };
         for (String library : builtins) {
             addBuiltinIfAllowed(library + ".rb", new BuiltinScript(library));
         }
-        
+
         RubyKernel.autoload(topSelf, newSymbol("Java"), newString("java"));
 
         if (config.getCompatVersion() == CompatVersion.RUBY1_9) {
@@ -1334,11 +1347,11 @@
     public String getCurrentDirectory() {
         return currentDirectory;
     }
-    
+
     public RubyModule getEtc() {
         return etcModule;
     }
-    
+
     public void setEtc(RubyModule etcModule) {
         this.etcModule = etcModule;
     }
@@ -1354,14 +1367,14 @@
     public RubyClass getClassClass() {
         return classClass;
     }
-    
+
     public RubyModule getKernel() {
         return kernelModule;
     }
     void setKernel(RubyModule kernelModule) {
         this.kernelModule = kernelModule;
     }
-    
+
     public RubyClass getDummy() {
         return dummyClass;
     }
@@ -1371,14 +1384,14 @@
     }
     void setComparable(RubyModule comparableModule) {
         this.comparableModule = comparableModule;
-    }    
+    }
 
     public RubyClass getNumeric() {
         return numericClass;
     }
     void setNumeric(RubyClass numericClass) {
         this.numericClass = numericClass;
-    }    
+    }
 
     public RubyClass getFloat() {
         return floatClass;
@@ -1386,14 +1399,14 @@
     void setFloat(RubyClass floatClass) {
         this.floatClass = floatClass;
     }
-    
+
     public RubyClass getInteger() {
         return integerClass;
     }
     void setInteger(RubyClass integerClass) {
         this.integerClass = integerClass;
-    }    
-    
+    }
+
     public RubyClass getFixnum() {
         return fixnumClass;
     }
@@ -1452,7 +1465,7 @@
 
     public RubyClass getArray() {
         return arrayClass;
-    }    
+    }
     void setArray(RubyClass arrayClass) {
         this.arrayClass = arrayClass;
     }
@@ -1532,77 +1545,77 @@
     }
     void setMethod(RubyClass methodClass) {
         this.methodClass = methodClass;
-    }    
+    }
 
     public RubyClass getUnboundMethod() {
         return unboundMethodClass;
     }
     void setUnboundMethod(RubyClass unboundMethodClass) {
         this.unboundMethodClass = unboundMethodClass;
-    }    
+    }
 
     public RubyClass getMatchData() {
         return matchDataClass;
     }
     void setMatchData(RubyClass matchDataClass) {
         this.matchDataClass = matchDataClass;
-    }    
+    }
 
     public RubyClass getRegexp() {
         return regexpClass;
     }
     void setRegexp(RubyClass regexpClass) {
         this.regexpClass = regexpClass;
-    }    
+    }
 
     public RubyClass getTime() {
         return timeClass;
     }
     void setTime(RubyClass timeClass) {
         this.timeClass = timeClass;
-    }    
+    }
 
     public RubyModule getMath() {
         return mathModule;
     }
     void setMath(RubyModule mathModule) {
         this.mathModule = mathModule;
-    }    
+    }
 
     public RubyModule getMarshal() {
         return marshalModule;
     }
     void setMarshal(RubyModule marshalModule) {
         this.marshalModule = marshalModule;
-    }    
+    }
 
     public RubyClass getBignum() {
         return bignumClass;
     }
     void setBignum(RubyClass bignumClass) {
         this.bignumClass = bignumClass;
-    }    
+    }
 
     public RubyClass getDir() {
         return dirClass;
     }
     void setDir(RubyClass dirClass) {
         this.dirClass = dirClass;
-    }    
+    }
 
     public RubyClass getFile() {
         return fileClass;
     }
     void setFile(RubyClass fileClass) {
         this.fileClass = fileClass;
-    }    
+    }
 
     public RubyClass getFileStat() {
         return fileStatClass;
     }
     void setFileStat(RubyClass fileStatClass) {
         this.fileStatClass = fileStatClass;
-    }    
+    }
 
     public RubyModule getFileTest() {
         return fileTestModule;
@@ -1610,20 +1623,20 @@
     void setFileTest(RubyModule fileTestModule) {
         this.fileTestModule = fileTestModule;
     }
-    
+
     public RubyClass getIO() {
         return ioClass;
     }
     void setIO(RubyClass ioClass) {
         this.ioClass = ioClass;
-    }    
+    }
 
     public RubyClass getThread() {
         return threadClass;
     }
     void setThread(RubyClass threadClass) {
         this.threadClass = threadClass;
-    }    
+    }
 
     public RubyClass getThreadGroup() {
         return threadGroupClass;
@@ -1631,7 +1644,7 @@
     void setThreadGroup(RubyClass threadGroupClass) {
         this.threadGroupClass = threadGroupClass;
     }
-    
+
     public RubyThreadGroup getDefaultThreadGroup() {
         return defaultThreadGroup;
     }
@@ -1644,14 +1657,14 @@
     }
     void setContinuation(RubyClass continuationClass) {
         this.continuationClass = continuationClass;
-    }    
+    }
 
     public RubyClass getStructClass() {
         return structClass;
     }
     void setStructClass(RubyClass structClass) {
         this.structClass = structClass;
-    }    
+    }
 
     public IRubyObject getTmsStruct() {
         return tmsStruct;
@@ -1659,7 +1672,7 @@
     void setTmsStruct(RubyClass tmsStruct) {
         this.tmsStruct = tmsStruct;
     }
-    
+
     public IRubyObject getPasswdStruct() {
         return passwdStruct;
     }
@@ -1679,43 +1692,43 @@
     }
     void setGC(RubyModule gcModule) {
         this.gcModule = gcModule;
-    }    
+    }
 
     public RubyModule getObjectSpaceModule() {
         return objectSpaceModule;
     }
     void setObjectSpaceModule(RubyModule objectSpaceModule) {
         this.objectSpaceModule = objectSpaceModule;
-    }    
+    }
 
     public RubyModule getProcess() {
         return processModule;
     }
     void setProcess(RubyModule processModule) {
         this.processModule = processModule;
-    }    
+    }
 
     public RubyClass getProcStatus() {
-        return procStatusClass; 
+        return procStatusClass;
     }
     void setProcStatus(RubyClass procStatusClass) {
         this.procStatusClass = procStatusClass;
     }
-    
+
     public RubyModule getProcUID() {
         return procUIDModule;
     }
     void setProcUID(RubyModule procUIDModule) {
         this.procUIDModule = procUIDModule;
     }
-    
+
     public RubyModule getProcGID() {
         return procGIDModule;
     }
     void setProcGID(RubyModule procGIDModule) {
         this.procGIDModule = procGIDModule;
     }
-    
+
     public RubyModule getProcSysModule() {
         return procSysModule;
     }
@@ -1780,11 +1793,11 @@
     public RubyClass getFatal() {
         return fatal;
     }
-    
+
     public RubyClass getInterrupt() {
         return interrupt;
     }
-    
+
     public RubyClass getTypeError() {
         return typeError;
     }
@@ -1796,7 +1809,7 @@
     public RubyClass getIndexError() {
         return indexError;
     }
-    
+
     public RubyClass getSyntaxError() {
         return syntaxError;
     }
@@ -1804,11 +1817,11 @@
     public RubyClass getStandardError() {
         return standardError;
     }
-    
+
     public RubyClass getRuntimeError() {
         return runtimeError;
     }
-    
+
     public RubyClass getIOError() {
         return ioError;
     }
@@ -1909,31 +1922,23 @@
         if (loader == null) {
             loader = ClassLoader.getSystemClassLoader();
         }
-        
+
         return loader;
     }
 
     public synchronized JRubyClassLoader getJRubyClassLoader() {
         // FIXME: Get rid of laziness and handle restricted access elsewhere
         if (!Ruby.isSecurityRestricted() && jrubyClassLoader == null) {
-            jrubyClassLoader = new JRubyClassLoader(config.getLoader());
+            jrubyClassLoader = new RuntimeContainer(config.getLoader(), this);
         }
-        
+
         return jrubyClassLoader;
     }
 
     /** Defines a global variable
      */
     public void defineVariable(final GlobalVariable variable) {
-        globalVariables.define(variable.name(), new IAccessor() {
-            public IRubyObject getValue() {
-                return variable.get();
-            }
-
-            public IRubyObject setValue(IRubyObject newValue) {
-                return variable.set(newValue);
-            }
-        });
+        globalVariables.define(variable.name(), new GlobalVariableAcessor(variable));
     }
 
     /** defines a readonly global variable
@@ -1942,7 +1947,7 @@
     public void defineReadonlyVariable(String name, IRubyObject value) {
         globalVariables.defineReadonly(name, new ValueAccessor(value));
     }
-    
+
     public Node parseFile(InputStream in, String file, DynamicScope scope) {
         if (parserStats != null) parserStats.addLoadParse();
         return parser.parse(file, in, scope, new ParserConfiguration(0, false, false, true));
@@ -1955,42 +1960,42 @@
 
     public Node parseEval(String content, String file, DynamicScope scope, int lineNumber) {
         byte[] bytes;
-        
+
         try {
             bytes = content.getBytes(KCode.NONE.getKCode());
         } catch (UnsupportedEncodingException e) {
             bytes = content.getBytes();
         }
-        
+
         if (parserStats != null) parserStats.addEvalParse();
-        return parser.parse(file, new ByteArrayInputStream(bytes), scope, 
+        return parser.parse(file, new ByteArrayInputStream(bytes), scope,
                 new ParserConfiguration(lineNumber, false));
     }
 
     @Deprecated
-    public Node parse(String content, String file, DynamicScope scope, int lineNumber, 
+    public Node parse(String content, String file, DynamicScope scope, int lineNumber,
             boolean extraPositionInformation) {
         byte[] bytes;
-        
+
         try {
             bytes = content.getBytes(KCode.NONE.getKCode());
         } catch (UnsupportedEncodingException e) {
             bytes = content.getBytes();
         }
 
-        return parser.parse(file, new ByteArrayInputStream(bytes), scope, 
+        return parser.parse(file, new ByteArrayInputStream(bytes), scope,
                 new ParserConfiguration(lineNumber, extraPositionInformation, false));
     }
-    
+
     public Node parseEval(ByteList content, String file, DynamicScope scope, int lineNumber) {
         if (parserStats != null) parserStats.addEvalParse();
         return parser.parse(file, content, scope, new ParserConfiguration(lineNumber, false));
     }
 
-    public Node parse(ByteList content, String file, DynamicScope scope, int lineNumber, 
+    public Node parse(ByteList content, String file, DynamicScope scope, int lineNumber,
             boolean extraPositionInformation) {
         if (parserStats != null) parserStats.addJRubyModuleParse();
-        return parser.parse(file, content, scope, 
+        return parser.parse(file, content, scope,
                 new ParserConfiguration(lineNumber, extraPositionInformation, false));
     }
 
@@ -2147,12 +2152,12 @@
             }
         }
     }
-    
+
     public void loadFile(String scriptName, InputStream in, boolean wrap) {
         IRubyObject self = wrap ? TopSelfFactory.createTopSelf(this) : getTopSelf();
         ThreadContext context = getCurrentContext();
         String file = context.getFile();
-        
+
         try {
             secure(4); /* should alter global state */
 
@@ -2167,20 +2172,20 @@
             context.setFile(file);
         }
     }
-    
+
     public void compileAndLoadFile(String filename, InputStream in, boolean wrap) {
         IRubyObject self = wrap ? TopSelfFactory.createTopSelf(this) : getTopSelf();
         ThreadContext context = getCurrentContext();
         String file = context.getFile();
-        
+
         try {
             secure(4); /* should alter global state */
 
             context.setFile(filename);
             context.preNodeEval(objectClass, self, filename);
-            
+
             Node scriptNode = parseFile(in, filename, null);
-            
+
             Script script = tryCompile(scriptNode, new JRubyClassLoader(jrubyClassLoader));
             if (script == null) {
                 System.err.println("Error, could not compile; pass -J-Djruby.jit.logging.verbose=true for more details");
@@ -2203,7 +2208,7 @@
             secure(4); /* should alter global state */
 
             context.preNodeEval(objectClass, self);
-            
+
             script.load(context, self, IRubyObject.NULL_ARRAY, Block.NULL_BLOCK);
         } catch (JumpException.ReturnJump rj) {
             return;
@@ -2214,16 +2219,16 @@
 
     public class CallTraceFuncHook extends EventHook {
         private RubyProc traceFunc;
-        
+
         public void setTraceFunc(RubyProc traceFunc) {
             this.traceFunc = traceFunc;
         }
-        
+
         public void eventHandler(ThreadContext context, String eventName, String file, int line, String name, IRubyObject type) {
             if (!context.isWithinTrace()) {
                 if (file == null) file = "(ruby)";
                 if (type == null) type = getFalse();
-                
+
                 RubyBinding binding = RubyBinding.newBinding(Ruby.this);
 
                 context.preTrace();
@@ -2246,14 +2251,14 @@
             return true;
         }
     };
-    
+
     private final CallTraceFuncHook callTraceFuncHook = new CallTraceFuncHook();
-    
+
     public void addEventHook(EventHook hook) {
         eventHooks.add(hook);
         hasEventHooks = true;
     }
-    
+
     public void removeEventHook(EventHook hook) {
         eventHooks.remove(hook);
         hasEventHooks = !eventHooks.isEmpty();
@@ -2261,15 +2266,15 @@
 
     public void setTraceFunction(RubyProc traceFunction) {
         removeEventHook(callTraceFuncHook);
-        
+
         if (traceFunction == null) {
             return;
         }
-        
+
         callTraceFuncHook.setTraceFunc(traceFunction);
         addEventHook(callTraceFuncHook);
     }
-    
+
     public void callEventHooks(ThreadContext context, RubyEvent event, String file, int line, String name, IRubyObject type) {
         for (EventHook eventHook : eventHooks) {
             if (eventHook.isInterestedInEvent(event)) {
@@ -2277,11 +2282,11 @@
             }
         }
     }
-    
+
     public boolean hasEventHooks() {
         return hasEventHooks;
     }
-    
+
     public GlobalVariables getGlobalVariables() {
         return globalVariables;
     }
@@ -2325,7 +2330,7 @@
             finalizers.put(finalizer, null);
         }
     }
-    
+
     public void removeInternalFinalizer(Finalizable finalizer) {
         synchronized (internalFinalizersMutex) {
             if (internalFinalizers != null) {
@@ -2435,15 +2440,15 @@
     public RubyArray newArray(IRubyObject[] objects) {
         return RubyArray.newArray(this, objects);
     }
-    
+
     public RubyArray newArrayNoCopy(IRubyObject[] objects) {
         return RubyArray.newArrayNoCopy(this, objects);
     }
-    
+
     public RubyArray newArrayNoCopyLight(IRubyObject[] objects) {
         return RubyArray.newArrayNoCopyLight(this, objects);
     }
-    
+
     public RubyArray newArray(List<IRubyObject> list) {
         return RubyArray.newArray(this, list);
     }
@@ -2459,7 +2464,7 @@
     public RubyFileStat newFileStat(String filename, boolean lstat) {
         return RubyFileStat.newFileStat(this, filename, lstat);
     }
-    
+
     public RubyFileStat newFileStat(FileDescriptor descriptor) {
         return RubyFileStat.newFileStat(this, descriptor);
     }
@@ -2514,7 +2519,7 @@
     public RubyString newString(String string) {
         return RubyString.newString(this, string);
     }
-    
+
     public RubyString newString(ByteList byteList) {
         return RubyString.newString(this, byteList);
     }
@@ -2522,7 +2527,7 @@
     @Deprecated
     public RubyString newStringShared(ByteList byteList) {
         return RubyString.newStringShared(this, byteList);
-    }    
+    }
 
     public RubySymbol newSymbol(String name) {
         return symbolTable.getSymbol(name);
@@ -2533,7 +2538,7 @@
      * name String. Don't intern your string just to call this version - the
      * overhead of interning will more than wipe out any benefit from the faster
      * lookup.
-     *   
+     *
      * @param internedName the symbol name, <em>must</em> be interned! if in
      *                     doubt, call {@link #newSymbol(String)} instead.
      * @return the symbol for name
@@ -2550,8 +2555,8 @@
 
     public RaiseException newRuntimeError(String message) {
         return newRaiseException(getRuntimeError(), message);
-    }    
-    
+    }
+
     public RaiseException newArgumentError(String message) {
         return newRaiseException(getArgumentError(), message);
     }
@@ -2635,14 +2640,14 @@
     public RaiseException newErrnoEEXISTError(String message) {
         return newRaiseException(getErrno().fastGetClass("EEXIST"), message);
     }
-    
+
     public RaiseException newErrnoEDOMError(String message) {
         return newRaiseException(getErrno().fastGetClass("EDOM"), "Domain error - " + message);
-    }   
-    
+    }
+
     public RaiseException newErrnoECHILDError() {
         return newRaiseException(getErrno().fastGetClass("ECHILD"), "No child processes");
-    }    
+    }
 
     public RaiseException newIndexError(String message) {
         return newRaiseException(getIndexError(), message);
@@ -2683,7 +2688,7 @@
     public RaiseException newNotImplementedError(String message) {
         return newRaiseException(getNotImplementedError(), message);
     }
-    
+
     public RaiseException newInvalidEncoding(String message) {
         return newRaiseException(fastGetClass("Iconv").fastGetClass("InvalidEncoding"), message);
     }
@@ -2803,6 +2808,14 @@
         return stackTraces;
     }
 
+    public IRubyObject getRuntimeVariable(String name) {
+        return this.runtimeVariables.get(name);
+    }
+
+    public void setRuntimeVariable(String name, IRubyObject value) {
+        this.runtimeVariables.put(name, value);
+    }
+
     public void setRandomSeed(long randomSeed) {
         this.randomSeed = randomSeed;
     }
@@ -2919,27 +2932,27 @@
     public static boolean isSecurityRestricted() {
         return securityRestricted;
     }
-    
+
     public static void setSecurityRestricted(boolean restricted) {
         securityRestricted = restricted;
     }
-    
+
     public POSIX getPosix() {
         return posix;
     }
-    
+
     public void setRecordSeparatorVar(GlobalVariable recordSeparatorVar) {
         this.recordSeparatorVar = recordSeparatorVar;
     }
-    
+
     public GlobalVariable getRecordSeparatorVar() {
         return recordSeparatorVar;
     }
-    
+
     public Set<Script> getJittedMethods() {
         return jittedMethods;
     }
-    
+
     public ExecutorService getExecutor() {
         return executor;
     }
@@ -2958,7 +2971,7 @@
 
     private volatile int constantGeneration = 1;
     private final ThreadService threadService;
-    
+
     private POSIX posix;
 
     private int stackTraces = 0;
@@ -2972,17 +2985,17 @@
     private Random random = new Random();
 
     private List<EventHook> eventHooks = new Vector<EventHook>();
-    private boolean hasEventHooks;  
+    private boolean hasEventHooks;
     private boolean globalAbortOnExceptionEnabled = false;
     private boolean doNotReverseLookupEnabled = false;
     private volatile boolean objectSpaceEnabled;
-    
+
     private final Set<Script> jittedMethods = Collections.synchronizedSet(new WeakHashSet<Script>());
-    
+
     private static ThreadLocal<Ruby> currentRuntime = new ThreadLocal<Ruby>();
-    
+
     private long globalState = 1;
-    
+
     private int safeLevel = -1;
 
     // Default objects
@@ -2994,7 +3007,7 @@
 
     private IRubyObject verbose;
     private IRubyObject debug;
-    
+
     private RubyThreadGroup defaultThreadGroup;
 
     /**
@@ -3029,7 +3042,7 @@
             marshalModule, etcModule, fileTestModule, gcModule,
             objectSpaceModule, processModule, procUIDModule, procGIDModule,
             procSysModule, precisionModule, errnoModule;
-    
+
     // record separator var, to speed up io ops that use it
     private GlobalVariable recordSeparatorVar;
 
@@ -3047,13 +3060,13 @@
     // Java support
     private JavaSupport javaSupport;
     private JRubyClassLoader jrubyClassLoader;
-    
+
     // Management/monitoring
     private BeanManager beanManager;
 
     // Parser stats
     private ParserStats parserStats;
-    
+
     // Compilation
     private final JITCompiler jitCompiler;
 
@@ -3081,7 +3094,8 @@
 
     private LoadService loadService;
     private EncodingService encodingService;
-    private GlobalVariables globalVariables = new GlobalVariables(this);
+    private GlobalVariables globalVariables = new GlobalVariables();
+    private Map<String, IRubyObject> runtimeVariables = new ConcurrentHashMap<String, IRubyObject>();
     private RubyWarnings warnings = new RubyWarnings(this);
 
     // Contains a list of all blocks (as Procs) that should be called when
@@ -3105,7 +3119,7 @@
      * weakly referenced, to be executed on tearDown.
      */
     private Map<Finalizable, Object> finalizers;
-    
+
     /**
      * A list of JRuby-internal finalizers,  weakly referenced,
      * to be executed on tearDown.
@@ -3117,7 +3131,8 @@
 
     // mutex that controls modifications of internal finalizers
     private final Object internalFinalizersMutex = new Object();
-    
+
     // A thread pool to use for executing this runtime's Ruby threads
     private ExecutorService executor;
+
 }
Index: src/org/jruby/RubyModule.java
===================================================================
--- src/org/jruby/RubyModule.java	(revision 8091)
+++ src/org/jruby/RubyModule.java	(working copy)
@@ -190,13 +190,16 @@
     private final Map<String, CacheEntry> cachedMethods = new ConcurrentHashMap<String, CacheEntry>(12, 0.75f, 1);
     
     protected static class Generation {
-        public volatile int hash;
+        private volatile int hash;
         public Generation() {
             hash = hashCode();
         }
         public synchronized void update() {
             hash = hash + (hashCode() * 31);
         }
+        public int hash() {
+            return hash;
+        }
     }
     protected final Generation generation;
     
@@ -946,7 +949,7 @@
     }
     
     public final int getSerialNumber() {
-        return generation.hash;
+        return generation.hash();
     }
     
     private CacheEntry cacheHit(String name) {
Index: src/org/jruby/util/RuntimeContainer.java
===================================================================
--- src/org/jruby/util/RuntimeContainer.java	(revision 0)
+++ src/org/jruby/util/RuntimeContainer.java	(revision 0)
@@ -0,0 +1,19 @@
+package org.jruby.util;
+
+import org.jruby.Ruby;
+
+/**
+ * @author Fabio Kung
+ */
+public class RuntimeContainer extends JRubyClassLoader {
+    private final Ruby runtime;
+
+    public RuntimeContainer(ClassLoader parent, Ruby runtime) {
+        super(parent);
+        this.runtime = runtime;
+    }
+
+    public Ruby getRuntime() {
+        return runtime;
+    }
+}
Index: src/org/jruby/util/io/ChannelDescriptor.java
===================================================================
--- src/org/jruby/util/io/ChannelDescriptor.java	(revision 8091)
+++ src/org/jruby/util/io/ChannelDescriptor.java	(working copy)
@@ -94,13 +94,6 @@
     private AtomicInteger refCounter;
 
     /**
-     * Used to work-around blocking problems with STDIN. In most cases <code>null</code>.
-     * See {@link #ChannelDescriptor(InputStream, int, ModeFlags, FileDescriptor)}
-     * for more details. You probably should not use it.
-     */
-    private InputStream baseInputStream;
-    
-    /**
      * Process streams get Channel.newChannel()ed into FileChannel but are not actually
      * seekable. So instead of just the isSeekable check doing instanceof FileChannel,
      * we must also add this boolean to check, which we set to false when it's known
@@ -148,28 +141,6 @@
     }
 
     /**
-     * Special constructor to create the ChannelDescriptor out of the stream, file number,
-     * mode flags, and file descriptor object. The channel will be created from the
-     * provided stream. The channel will be kept open until all ChannelDescriptor
-     * references to it have been closed. <b>Note:</b> in most cases, you should not
-     * use this constructor, it's reserved mostly for STDIN.
-     *
-     * @param baseInputStream The stream to create the channel for the new descriptor
-     * @param fileno The file number for the new descriptor
-     * @param originalModes The mode flags for the new descriptor
-     * @param fileDescriptor The java.io.FileDescriptor object for the new descriptor
-     */
-    public ChannelDescriptor(InputStream baseInputStream, int fileno, ModeFlags originalModes, FileDescriptor fileDescriptor) {
-        // The reason why we need the stream is to be able to invoke available() on it.
-        // STDIN in Java is non-interruptible, non-selectable, and attempt to read
-        // on such stream might lead to thread being blocked without *any* way to unblock it.
-        // That's where available() comes it, so at least we could check whether
-        // anything is available to be read without blocking.
-        this(Channels.newChannel(baseInputStream), fileno, originalModes, fileDescriptor, new AtomicInteger(1), true);
-        this.baseInputStream = baseInputStream;
-    }
-
-    /**
      * Construct a new ChannelDescriptor with the given channel, file number,
      * and file descriptor object. The channel will be kept open until all ChannelDescriptor
      * references to it have been closed. The channel's capabilities will be used
@@ -217,30 +188,20 @@
     }
 
     /**
-     * This is intentionally non-public, since it should not be really
-     * used outside of very limited use case (handling of STDIN).
-     * See {@link #ChannelDescriptor(InputStream, int, ModeFlags, FileDescriptor)}
-     * for more info.
-     */
-    /*package-protected*/ InputStream getBaseInputStream() {
-        return baseInputStream;
-    }
-
-    /**
      * Whether the channel associated with this descriptor is seekable (i.e.
      * whether it is instanceof FileChannel).
      * 
      * @return true if the associated channel is seekable, false otherwise
      */
     public boolean isSeekable() {
-        return canBeSeekable && channel instanceof FileChannel;
+        return canBeSeekable && getChannel() instanceof FileChannel;
     }
     
     /**
      * Set the channel to be explicitly seekable or not, for streams that appear
      * to be seekable with the instanceof FileChannel check.
      * 
-     * @param seekable Whether the channel is seekable or not.
+     * @param canBeSeekable Whether the channel is seekable or not.
      */
     public void setCanBeSeekable(boolean canBeSeekable) {
         this.canBeSeekable = canBeSeekable;
@@ -251,7 +212,7 @@
      * for which many operations are simply noops.
      */
     public boolean isNull() {
-        return channel instanceof NullChannel;
+        return getChannel() instanceof NullChannel;
     }
 
     /**
@@ -261,7 +222,7 @@
      * @return true if the associated channel is writable, false otherwise
      */
     public boolean isWritable() {
-        return channel instanceof WritableByteChannel;
+        return getChannel() instanceof WritableByteChannel;
     }
     
     /**
@@ -270,7 +231,7 @@
      * @return true if the associated channel is open, false otherwise
      */
     public boolean isOpen() {
-        return channel.isOpen();
+        return getChannel().isOpen();
     }
     
     /**
@@ -321,7 +282,7 @@
             
             if (DEBUG) getLogger("ChannelDescriptor").info("Reopen fileno " + newFileno + ", refs now: " + refCounter.get());
 
-            return new ChannelDescriptor(channel, newFileno, originalModes, fileDescriptor, refCounter, canBeSeekable);
+            return new ChannelDescriptor(getChannel(), newFileno, originalModes, fileDescriptor, refCounter, canBeSeekable);
         }
     }
     
@@ -338,7 +299,7 @@
 
             if (DEBUG) getLogger("ChannelDescriptor").info("Reopen fileno " + fileno + ", refs now: " + refCounter.get());
 
-            return new ChannelDescriptor(channel, fileno, originalModes, fileDescriptor, refCounter, canBeSeekable);
+            return new ChannelDescriptor(getChannel(), fileno, originalModes, fileDescriptor, refCounter, canBeSeekable);
         }
     }
     
@@ -386,10 +347,10 @@
      * @return the new offset into the FileChannel.
      */
     public long lseek(long offset, int whence) throws IOException, InvalidValueException, PipeException, BadDescriptorException {
-        if (channel instanceof FileChannel) {
+        if (getChannel() instanceof FileChannel) {
             checkOpen();
             
-            FileChannel fileChannel = (FileChannel)channel;
+            FileChannel fileChannel = (FileChannel)getChannel();
             try {
                 long pos;
                 switch (whence) {
@@ -459,7 +420,7 @@
     public int read(ByteBuffer buffer) throws IOException, BadDescriptorException {
         checkOpen();
         
-        ReadableByteChannel readChannel = (ReadableByteChannel) channel;
+        ReadableByteChannel readChannel = (ReadableByteChannel) getChannel();
         int bytesRead = 0;
         bytesRead = readChannel.read(buffer);
 
@@ -478,10 +439,10 @@
     public int internalWrite(ByteBuffer buffer) throws IOException, BadDescriptorException {
         checkOpen();
         
-        WritableByteChannel writeChannel = (WritableByteChannel)channel;
+        WritableByteChannel writeChannel = (WritableByteChannel)getChannel();
         
         if (isSeekable() && originalModes.isAppendable()) {
-            FileChannel fileChannel = (FileChannel)channel;
+            FileChannel fileChannel = (FileChannel)getChannel();
             fileChannel.position(fileChannel.size());
         }
         
@@ -677,7 +638,7 @@
             }
 
             // if channel is already closed, we're no longer valid
-            if (!channel.isOpen()) {
+            if (!getChannel().isOpen()) {
                 throw new BadDescriptorException();
             }
 
@@ -687,7 +648,7 @@
             if (DEBUG) getLogger("ChannelDescriptor").info("Descriptor for fileno " + fileno + " refs: " + count);
 
             if (count <= 0) {
-                channel.close();
+                getChannel().close();
             }
         }
     }
Index: src/org/jruby/util/io/ChannelStream.java
===================================================================
--- src/org/jruby/util/io/ChannelStream.java	(revision 8091)
+++ src/org/jruby/util/io/ChannelStream.java	(working copy)
@@ -87,10 +87,9 @@
     private final static int BULK_READ_SIZE = 16 * 1024;
     private final static ByteBuffer EMPTY_BUFFER = ByteBuffer.allocate(0);
     
-    private Ruby runtime;
     protected ModeFlags modes;
     protected boolean sync = false;
-    
+
     protected volatile ByteBuffer buffer; // r/w buffer
     protected boolean reading; // are we reading or writing?
     private ChannelDescriptor descriptor;
@@ -100,25 +99,23 @@
 
     private boolean eof = false;
 
-    public ChannelStream(Ruby runtime, ChannelDescriptor descriptor, ModeFlags modes, FileDescriptor fileDescriptor) throws InvalidValueException {
+    public ChannelStream(ChannelDescriptor descriptor, ModeFlags modes, FileDescriptor fileDescriptor) throws InvalidValueException {
         descriptor.checkNewModes(modes);
-        
-        this.runtime = runtime;
+
         this.descriptor = descriptor;
         this.modes = modes;
         this.buffer = ByteBuffer.allocate(BUFSIZE);
         buffer.flip();
         this.reading = true;
-        
+
         // this constructor is used by fdopen, so we don't increment descriptor ref count
     }
 
-    public ChannelStream(Ruby runtime, ChannelDescriptor descriptor) {
-        this(runtime, descriptor, descriptor.getFileDescriptor());
+    public ChannelStream(ChannelDescriptor descriptor) {
+        this(descriptor, descriptor.getFileDescriptor());
     }
 
-    public ChannelStream(Ruby runtime, ChannelDescriptor descriptor, FileDescriptor fileDescriptor) {
-        this.runtime = runtime;
+    public ChannelStream(ChannelDescriptor descriptor, FileDescriptor fileDescriptor) {
         this.descriptor = descriptor;
         this.modes = descriptor.getOriginalModes();
         buffer = ByteBuffer.allocate(BUFSIZE);
@@ -126,10 +123,9 @@
         this.reading = true;
     }
 
-    public ChannelStream(Ruby runtime, ChannelDescriptor descriptor, ModeFlags modes) throws InvalidValueException {
+    public ChannelStream(ChannelDescriptor descriptor, ModeFlags modes) throws InvalidValueException {
         descriptor.checkNewModes(modes);
-        
-        this.runtime = runtime;
+
         this.descriptor = descriptor;
         this.modes = modes;
         buffer = ByteBuffer.allocate(BUFSIZE);
@@ -138,9 +134,9 @@
     }
 
     public Ruby getRuntime() {
-        return runtime;
+        return Ruby.getCurrentRuntime();
     }
-    
+
     public void checkReadable() throws IOException {
         if (!modes.isReadable()) throw new IOException("not opened for reading");
     }
@@ -152,11 +148,11 @@
     public void checkPermissionsSubsetOf(ModeFlags subsetModes) {
         subsetModes.isSubsetOf(modes);
     }
-    
+
     public ModeFlags getModes() {
     	return modes;
     }
-    
+
     public boolean isSync() {
         return sync;
     }
@@ -176,11 +172,11 @@
             Thread.sleep(10);
         }
     }
-    
+
     public boolean readDataBuffered() {
         return reading && buffer.hasRemaining();
     }
-    
+
     public boolean writeDataBuffered() {
         return !reading && buffer.position() > 0;
     }
@@ -202,22 +198,22 @@
             PARAGRAPH_SEPARATOR : separatorString;
 
         descriptor.checkOpen();
-        
+
         if (feof()) {
             return null;
         }
-        
+
         int c = read();
-        
+
         if (c == -1) {
             return null;
         }
-        
+
         // unread back
         buffer.position(buffer.position() - 1);
 
         ByteList buf = new ByteList(40);
-        
+
         byte first = separator.bytes[separator.begin];
 
         LineLoop : while (true) {
@@ -225,7 +221,7 @@
                 byte[] bytes = buffer.array();
                 int offset = buffer.position();
                 int max = buffer.limit();
-                
+
                 // iterate over remainder of buffer until we find a match
                 for (int i = offset; i < max; i++) {
                     c = bytes[i];
@@ -240,13 +236,13 @@
                         break ReadLoop;
                     }
                 }
-                
+
                 // no match, append remainder of buffer and continue with next block
                 buf.append(bytes, offset, buffer.remaining());
                 int read = refillBuffer();
                 if (read == -1) break LineLoop;
             }
-            
+
             // found a match above, check if remaining separator characters match, appending as we go
             for (int i = 0; i < separator.realSize; i++) {
                 if (c == -1) {
@@ -272,7 +268,7 @@
 
         return buf;
     }
-    
+
     /**
      * An version of read that reads all bytes up to and including a terminator byte.
      * <p>
@@ -282,7 +278,7 @@
      * @param dst The output buffer.
      * @param terminator The byte to terminate reading.
      * @return The number of bytes read, or -1 if EOF is reached.
-     * 
+     *
      * @throws java.io.IOException
      * @throws org.jruby.util.io.BadDescriptorException
      */
@@ -290,7 +286,7 @@
         checkReadable();
         ensureRead();
         descriptor.checkOpen();
-        
+
         int totalRead = 0;
         boolean found = false;
         if (ungotc != -1) {
@@ -324,7 +320,7 @@
         }
         return totalRead;
     }
-    
+
     public synchronized ByteList readall() throws IOException, BadDescriptorException {
         if (descriptor.isSeekable()) {
             invalidateBuffer();
@@ -336,7 +332,7 @@
             }
             left += ungotc != -1 ? 1 : 0;
             ByteList result = new ByteList((int) left);
-            ByteBuffer buf = ByteBuffer.wrap(result.unsafeBytes(), 
+            ByteBuffer buf = ByteBuffer.wrap(result.unsafeBytes(),
                     result.begin(), (int) left);
             if (ungotc != -1) {
                 buf.put((byte) ungotc);
@@ -358,7 +354,7 @@
 
             ByteList byteList = new ByteList();
             ByteList read = fread(BUFSIZE);
-            
+
             if (read == null) {
                 eof = true;
                 return byteList;
@@ -370,14 +366,14 @@
             }
 
             return byteList;
-        } 
+        }
     }
-    
+
     /**
      * <p>Close IO handler resources.</p>
-     * @throws IOException 
-     * @throws BadDescriptorException 
-     * 
+     * @throws IOException
+     * @throws BadDescriptorException
+     *
      * @see org.jruby.util.IOHandler#close()
      */
     public synchronized void fclose() throws IOException, BadDescriptorException {
@@ -408,7 +404,7 @@
     /**
      * Internal close, to safely work for finalizing.
      * @param finalizing true if this is in a finalizing context
-     * @throws IOException 
+     * @throws IOException
      * @throws BadDescriptorException
      */
     private void closeForFinalize() {
@@ -422,8 +418,8 @@
     }
 
     /**
-     * @throws IOException 
-     * @throws BadDescriptorException 
+     * @throws IOException
+     * @throws BadDescriptorException
      * @see org.jruby.util.IOHandler#flush()
      */
     public synchronized int fflush() throws IOException, BadDescriptorException {
@@ -435,14 +431,14 @@
         }
         return 0;
     }
-    
+
     /**
      * Flush the write buffer to the channel (if needed)
      * @throws IOException
      */
     private void flushWrite() throws IOException, BadDescriptorException {
         if (reading || !modes.isWritable() || buffer.position() == 0) return; // Don't bother
-        
+
         int len = buffer.position();
         buffer.flip();
         int n = descriptor.write(buffer);
@@ -452,7 +448,7 @@
         }
         buffer.clear();
     }
-    
+
     /**
      * Flush the write buffer to the channel (if needed)
      * @throws IOException
@@ -494,12 +490,7 @@
      * @see org.jruby.util.IOHandler#getInputStream()
      */
     public InputStream newInputStream() {
-        InputStream in = descriptor.getBaseInputStream();
-        if (in == null) {
-            return new BufferedInputStream(Channels.newInputStream((ReadableByteChannel)descriptor.getChannel()));
-        } else {
-            return in;
-        }
+        return new BufferedInputStream(Channels.newInputStream((ReadableByteChannel) descriptor.getChannel()));
     }
 
     /**
@@ -508,28 +499,28 @@
     public OutputStream newOutputStream() {
         return new BufferedOutputStream(Channels.newOutputStream((WritableByteChannel)descriptor.getChannel()));
     }
-    
+
     public void clearerr() {
         eof = false;
     }
-    
+
     /**
-     * @throws IOException 
-     * @throws BadDescriptorException 
+     * @throws IOException
+     * @throws BadDescriptorException
      * @see org.jruby.util.IOHandler#isEOF()
      */
     public boolean feof() throws IOException, BadDescriptorException {
         checkReadable();
-        
+
         if (eof) {
             return true;
         } else {
             return false;
         }
     }
-    
+
     /**
-     * @throws IOException 
+     * @throws IOException
      * @see org.jruby.util.IOHandler#pos()
      */
     public synchronized long fgetpos() throws IOException, PipeException, InvalidValueException, BadDescriptorException {
@@ -550,14 +541,14 @@
             throw new PipeException();
         }
     }
-    
+
     /**
      * Implementation of libc "lseek", which seeks on seekable streams, raises
      * EPIPE if the fd is assocated with a pipe, socket, or FIFO, and doesn't
      * do anything for other cases (like stdio).
-     * 
-     * @throws IOException 
-     * @throws InvalidValueException 
+     *
+     * @throws IOException
+     * @throws InvalidValueException
      * @see org.jruby.util.IOHandler#seek(long, int)
      */
     public synchronized void lseek(long offset, int type) throws IOException, InvalidValueException, PipeException, BadDescriptorException {
@@ -636,7 +627,7 @@
             reading = true;
         }
     }
-    
+
     private void resetForWrite() throws IOException {
         if (descriptor.isSeekable()) {
             FileChannel fileChannel = (FileChannel)descriptor.getChannel();
@@ -648,7 +639,7 @@
         buffer.clear();
         reading = false;
     }
-    
+
     /**
      * Ensure buffer is ready for writing.
      * @throws IOException
@@ -661,25 +652,25 @@
     public synchronized ByteList read(int number) throws IOException, BadDescriptorException {
         checkReadable();
         ensureReadNonBuffered();
-        
+
         ByteList byteList = new ByteList(number);
-        
+
         // TODO this should entry into error handling somewhere
         int bytesRead = descriptor.read(number, byteList);
-        
+
         if (bytesRead == -1) {
             eof = true;
         }
-        
+
         return byteList;
     }
 
     private ByteList bufferedRead(int number) throws IOException, BadDescriptorException {
         checkReadable();
         ensureRead();
-        
+
         ByteList result = new ByteList(0);
-        
+
         int len = -1;
         if (buffer.hasRemaining()) { // already have some bytes buffered
             len = (number <= buffer.remaining()) ? number : buffer.remaining();
@@ -704,26 +695,26 @@
                 break;
             }
         }
-        
+
         //
         // Complete the request by filling the read buffer first
         //
         while (!done && result.length() != number) {
             int read = refillBuffer();
-            
+
             if (read == -1) {
                 eof = true;
                 break;
             } else if (read == 0) {
                 break;
             }
-            
+
             // append what we read into our buffer and allow the loop to continue
             int desired = number - result.length();
             len = (desired < read) ? desired : read;
             result.append(buffer, len);
         }
-        
+
         if (result.length() == 0 && number != 0) {
             if (eof) {
                 throw new EOFException();
@@ -731,10 +722,10 @@
         }
         return result;
     }
-    
+
     private int bufferedRead() throws IOException, BadDescriptorException {
         ensureRead();
-        
+
         if (!buffer.hasRemaining()) {
             int len = refillBuffer();
             if (len == -1) {
@@ -746,42 +737,42 @@
         }
         return buffer.get() & 0xFF;
     }
-    
+
     /**
-     * @throws IOException 
-     * @throws BadDescriptorException 
+     * @throws IOException
+     * @throws BadDescriptorException
      * @see org.jruby.util.IOHandler#syswrite(String buf)
      */
     private int bufferedWrite(ByteList buf) throws IOException, BadDescriptorException {
         getRuntime().secure(4);
         checkWritable();
         ensureWrite();
-        
+
         // Ruby ignores empty syswrites
         if (buf == null || buf.length() == 0) return 0;
-        
+
         if (buf.length() > buffer.capacity()) { // Doesn't fit in buffer. Write immediately.
             flushWrite(); // ensure nothing left to write
-            
 
+
             int n = descriptor.write(ByteBuffer.wrap(buf.unsafeBytes(), buf.begin(), buf.length()));
             if(n != buf.length()) {
                 // TODO: check the return value here
             }
         } else {
             if (buf.length() > buffer.remaining()) flushWrite();
-            
+
             buffer.put(buf.unsafeBytes(), buf.begin(), buf.length());
         }
-        
+
         if (isSync()) sync();
-        
+
         return buf.realSize;
     }
-    
+
     /**
-     * @throws IOException 
-     * @throws BadDescriptorException 
+     * @throws IOException
+     * @throws BadDescriptorException
      * @see org.jruby.util.IOHandler#syswrite(String buf)
      */
     private int bufferedWrite(int c) throws IOException, BadDescriptorException {
@@ -790,14 +781,14 @@
         ensureWrite();
 
         if (!buffer.hasRemaining()) flushWrite();
-        
+
         buffer.put((byte) c);
-            
+
         if (isSync()) sync();
-            
+
         return 1;
     }
-    
+
     public synchronized void ftruncate(long newLength) throws IOException,
             BadDescriptorException, InvalidValueException {
         Channel ch = descriptor.getChannel();
@@ -810,20 +801,20 @@
             // truncate can't lengthen files, so we save position, seek/write, and go back
             long position = fileChannel.position();
             int difference = (int)(newLength - fileChannel.size());
-            
+
             fileChannel.position(fileChannel.size());
             // FIXME: This worries me a bit, since it could allocate a lot with a large newLength
             fileChannel.write(ByteBuffer.allocate(difference));
             fileChannel.position(position);
         } else {
             fileChannel.truncate(newLength);
-        }        
+        }
     }
-    
+
     /**
      * Invalidate buffer before a position change has occurred (e.g. seek),
      * flushing writes if required, and correcting file position if reading
-     * @throws IOException 
+     * @throws IOException
      */
     private void invalidateBuffer() throws IOException, BadDescriptorException {
         if (!reading) flushWrite();
@@ -862,13 +853,13 @@
         if (c == -1) {
             return -1;
         }
-        
+
         // putting a bit back, so we're not at EOF anymore
         eof = false;
 
         // save the ungot
         ungotc = c;
-        
+
         return c;
     }
 
@@ -876,7 +867,7 @@
         if (eof) {
             return -1;
         }
-        
+
         checkReadable();
 
         int c = read();
@@ -885,7 +876,7 @@
             eof = true;
             return c;
         }
-        
+
         return c & 0xff;
     }
 
@@ -896,12 +887,12 @@
         getRuntime().secure(4);
         checkWritable();
         ensureWrite();
-        
+
         // Ruby ignores empty syswrites
         if (buf == null || buf.length() == 0) return 0;
-        
+
         if (buffer.position() != 0 && !flushWrite(false)) return 0;
-        
+
         if (descriptor.getChannel() instanceof SelectableChannel) {
             SelectableChannel selectableChannel = (SelectableChannel)descriptor.getChannel();
             synchronized (selectableChannel.blockingLock()) {
@@ -1002,13 +993,13 @@
         } else {
             // otherwise, we try an unbuffered read to get whatever's available
             return read(number);
-        }        
+        }
     }
 
     public synchronized int read() throws IOException, BadDescriptorException {
         try {
             descriptor.checkOpen();
-            
+
             if (ungotc >= 0) {
                 int c = ungotc;
                 ungotc = -1;
@@ -1021,11 +1012,11 @@
             return -1;
         }
     }
-    
+
     public ChannelDescriptor getDescriptor() {
         return descriptor;
     }
-    
+
     public void setBlocking(boolean block) throws IOException {
         if (!(descriptor.getChannel() instanceof SelectableChannel)) {
             return;
@@ -1059,7 +1050,7 @@
         if (descriptor.isOpen()) {
             descriptor.close();
         }
-        
+
         if (path.equals("/dev/null") || path.equalsIgnoreCase("nul:") || path.equalsIgnoreCase("nul")) {
             descriptor = new ChannelDescriptor(new NullChannel(), descriptor.getFileno(), modes, new FileDescriptor());
         } else {
@@ -1083,27 +1074,27 @@
             RandomAccessFile file = new RandomAccessFile(theFile, modes.toJavaModeString());
 
             if (modes.isTruncate()) file.setLength(0L);
-            
+
             descriptor = new ChannelDescriptor(file.getChannel(), descriptor.getFileno(), modes, file.getFD());
-        
+
             if (modes.isAppendable()) lseek(0, SEEK_END);
         }
     }
-    
+
     public static Stream fopen(Ruby runtime, String path, ModeFlags modes) throws FileNotFoundException, DirectoryAsFileException, FileExistsException, IOException, InvalidValueException, PipeException, BadDescriptorException {
         String cwd = runtime.getCurrentDirectory();
-        
+
         ChannelDescriptor descriptor = ChannelDescriptor.open(cwd, path, modes);
-        
+
         Stream stream = fdopen(runtime, descriptor, modes);
-        
+
         if (modes.isAppendable()) stream.lseek(0, Stream.SEEK_END);
-        
+
         return stream;
     }
-    
+
     public static Stream fdopen(Ruby runtime, ChannelDescriptor descriptor, ModeFlags modes) throws InvalidValueException {
-        Stream handler = new ChannelStream(runtime, descriptor, modes, descriptor.getFileDescriptor());
+        Stream handler = new ChannelStream(descriptor, modes, descriptor.getFileDescriptor());
         
         return handler;
     }
Index: src/org/jruby/RubyGlobal.java
===================================================================
--- src/org/jruby/RubyGlobal.java	(revision 8091)
+++ src/org/jruby/RubyGlobal.java	(working copy)
@@ -43,29 +43,28 @@
 import org.jruby.common.IRubyWarnings.ID;
 import org.jruby.environment.OSEnvironmentReaderExcepton;
 import org.jruby.environment.OSEnvironment;
-import org.jruby.internal.runtime.ValueAccessor;
+import org.jruby.internal.runtime.RuntimeVariableAccessor;
 import org.jruby.javasupport.JavaUtil;
 import org.jruby.javasupport.util.RuntimeHelpers;
 import org.jruby.runtime.Constants;
 import org.jruby.runtime.GlobalVariable;
-import org.jruby.runtime.IAccessor;
 import org.jruby.runtime.ReadonlyGlobalVariable;
 import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.builtin.IRubyObject;
 import org.jruby.util.KCode;
 
 /** This class initializes global variables and constants.
- * 
+ *
  * @author jpetersen
  */
 public class RubyGlobal {
-    
+
     /**
      * Obligate string-keyed and string-valued hash, used for ENV and ENV_JAVA
-     * 
+     *
      */
     public static class StringOnlyRubyHash extends RubyHash {
-        
+
         public StringOnlyRubyHash(Ruby runtime, Map valueMap, IRubyObject defaultValue) {
             super(runtime, valueMap, defaultValue);
         }
@@ -95,26 +94,26 @@
             if (value.isNil()) {
                 return super.delete(context, key, org.jruby.runtime.Block.NULL_BLOCK);
             }
-            
+
             //return super.aset(getRuntime().newString("sadfasdF"), getRuntime().newString("sadfasdF"));
             return super.op_aset(context, RuntimeHelpers.invoke(context, key, "to_str"),
                     value.isNil() ? getRuntime().getNil() : RuntimeHelpers.invoke(context, value, "to_str"));
         }
-        
+
         @JRubyMethod
         @Override
         public IRubyObject to_s(){
             return getRuntime().newString("ENV");
         }
     }
-    
+
     public static void createGlobals(ThreadContext context, Ruby runtime) {
         runtime.defineGlobalConstant("TOPLEVEL_BINDING", runtime.newBinding());
-        
+
         runtime.defineGlobalConstant("TRUE", runtime.getTrue());
         runtime.defineGlobalConstant("FALSE", runtime.getFalse());
         runtime.defineGlobalConstant("NIL", runtime.getNil());
-        
+
         // define ARGV and $* for this runtime
         RubyArray argvArray = runtime.newArray();
         String[] argv = runtime.getInstanceConfig().getArgv();
@@ -122,12 +121,11 @@
             argvArray.append(RubyString.newStringShared(runtime, argv[i].getBytes()));
         }
         runtime.defineGlobalConstant("ARGV", argvArray);
-        runtime.getGlobalVariables().defineReadonly("$*", new ValueAccessor(argvArray));
+        runtime.getGlobalVariables().defineReadonly("$*", new RuntimeVariableAccessor("$*", argvArray));
 
-        IAccessor d = new ValueAccessor(runtime.newString(
-                runtime.getInstanceConfig().displayedFileName()));
-        runtime.getGlobalVariables().define("$PROGRAM_NAME", d);
-        runtime.getGlobalVariables().define("$0", d);
+        RubyString fileName = runtime.newString(runtime.getInstanceConfig().displayedFileName());
+        runtime.getGlobalVariables().define("$PROGRAM_NAME", new RuntimeVariableAccessor("$PROGRAM_NAME", fileName));
+        runtime.getGlobalVariables().define("$0", new RuntimeVariableAccessor("$0", fileName));
 
         // Version information:
         IRubyObject version = runtime.newString(Constants.RUBY_VERSION).freeze(context);
@@ -144,36 +142,36 @@
         runtime.defineGlobalConstant("VERSION", version);
         runtime.defineGlobalConstant("RELEASE_DATE", release);
         runtime.defineGlobalConstant("PLATFORM", platform);
-        
+
         IRubyObject jrubyVersion = runtime.newString(Constants.VERSION).freeze(context);
         runtime.defineGlobalConstant("JRUBY_VERSION", jrubyVersion);
-		
-        GlobalVariable kcodeGV = new KCodeGlobalVariable(runtime, "$KCODE", runtime.newString("NONE"));
+
+        GlobalVariable kcodeGV = new KCodeGlobalVariable("$KCODE", runtime.newString("NONE"));
         runtime.defineVariable(kcodeGV);
         runtime.defineVariable(new GlobalVariable.Copy(runtime, "$-K", kcodeGV));
         IRubyObject defaultRS = runtime.newString(runtime.getInstanceConfig().getRecordSeparator()).freeze(context);
-        GlobalVariable rs = new StringGlobalVariable(runtime, "$/", defaultRS);
+        GlobalVariable rs = new StringGlobalVariable("$/", defaultRS);
         runtime.defineVariable(rs);
         runtime.setRecordSeparatorVar(rs);
         runtime.getGlobalVariables().setDefaultSeparator(defaultRS);
-        runtime.defineVariable(new StringGlobalVariable(runtime, "$\\", runtime.getNil()));
-        runtime.defineVariable(new StringGlobalVariable(runtime, "$,", runtime.getNil()));
+        runtime.defineVariable(new StringGlobalVariable("$\\", runtime.getNil()));
+        runtime.defineVariable(new StringGlobalVariable("$,", runtime.getNil()));
 
-        runtime.defineVariable(new LineNumberGlobalVariable(runtime, "$.", RubyFixnum.one(runtime)));
-        runtime.defineVariable(new LastlineGlobalVariable(runtime, "$_"));
-        runtime.defineVariable(new LastExitStatusVariable(runtime, "$?"));
+        runtime.defineVariable(new LineNumberGlobalVariable("$.", RubyFixnum.one(runtime)));
+        runtime.defineVariable(new LastlineGlobalVariable("$_"));
+        runtime.defineVariable(new LastExitStatusVariable("$?"));
 
-        runtime.defineVariable(new ErrorInfoGlobalVariable(runtime, "$!", runtime.getNil()));
-        runtime.defineVariable(new NonEffectiveGlobalVariable(runtime, "$=", runtime.getFalse()));
+        runtime.defineVariable(new ErrorInfoGlobalVariable("$!", runtime.getNil()));
+        runtime.defineVariable(new NonEffectiveGlobalVariable("$=", runtime.getFalse()));
 
         if(runtime.getInstanceConfig().getInputFieldSeparator() == null) {
-            runtime.defineVariable(new GlobalVariable(runtime, "$;", runtime.getNil()));
+            runtime.defineVariable(new GlobalVariable("$;", runtime.getNil()));
         } else {
-            runtime.defineVariable(new GlobalVariable(runtime, "$;", RubyRegexp.newRegexp(runtime, runtime.getInstanceConfig().getInputFieldSeparator(), 0)));
+            runtime.defineVariable(new GlobalVariable("$;", RubyRegexp.newRegexp(runtime, runtime.getInstanceConfig().getInputFieldSeparator(), 0)));
         }
-        
+
         Boolean verbose = runtime.getInstanceConfig().getVerbose();
-        IRubyObject verboseValue = null;
+        IRubyObject verboseValue;
         if (verbose == null) {
             verboseValue = runtime.getNil();
         } else if(verbose == Boolean.TRUE) {
@@ -181,68 +179,67 @@
         } else {
             verboseValue = runtime.getFalse();
         }
-        runtime.defineVariable(new VerboseGlobalVariable(runtime, "$VERBOSE", verboseValue));
-        
+        runtime.defineVariable(new VerboseGlobalVariable("$VERBOSE", verboseValue));
+
         IRubyObject debug = runtime.newBoolean(runtime.getInstanceConfig().isDebug());
-        runtime.defineVariable(new DebugGlobalVariable(runtime, "$DEBUG", debug));
-        runtime.defineVariable(new DebugGlobalVariable(runtime, "$-d", debug));
+        runtime.defineVariable(new DebugGlobalVariable("$DEBUG", debug));
+        runtime.defineVariable(new DebugGlobalVariable("$-d", debug));
 
-        runtime.defineVariable(new SafeGlobalVariable(runtime, "$SAFE"));
+        runtime.defineVariable(new SafeGlobalVariable("$SAFE"));
 
-        runtime.defineVariable(new BacktraceGlobalVariable(runtime, "$@"));
+        runtime.defineVariable(new BacktraceGlobalVariable("$@"));
 
         IRubyObject stdin = new RubyIO(runtime, STDIO.IN);
         IRubyObject stdout = new RubyIO(runtime, STDIO.OUT);
         IRubyObject stderr = new RubyIO(runtime, STDIO.ERR);
 
-        runtime.defineVariable(new InputGlobalVariable(runtime, "$stdin", stdin));
+        runtime.getGlobalVariables().define("$stdin", new RuntimeVariableAccessor("$stdin", stdin));
 
-        runtime.defineVariable(new OutputGlobalVariable(runtime, "$stdout", stdout));
+        runtime.getGlobalVariables().define("$stdout", new RuntimeOutputAccessor("$stdout", stdout));
         runtime.getGlobalVariables().alias("$>", "$stdout");
         runtime.getGlobalVariables().alias("$defout", "$stdout");
 
-        runtime.defineVariable(new OutputGlobalVariable(runtime, "$stderr", stderr));
+        runtime.getGlobalVariables().define("$stderr", new RuntimeOutputAccessor("$stderr", stderr));
         runtime.getGlobalVariables().alias("$deferr", "$stderr");
 
         runtime.defineGlobalConstant("STDIN", stdin);
         runtime.defineGlobalConstant("STDOUT", stdout);
         runtime.defineGlobalConstant("STDERR", stderr);
 
-        runtime.defineVariable(new LoadedFeatures(runtime, "$\""));
-        runtime.defineVariable(new LoadedFeatures(runtime, "$LOADED_FEATURES"));
+        runtime.defineVariable(new LoadedFeatures("$\""));
+        runtime.defineVariable(new LoadedFeatures("$LOADED_FEATURES"));
 
-        runtime.defineVariable(new LoadPath(runtime, "$:"));
-        runtime.defineVariable(new LoadPath(runtime, "$-I"));
-        runtime.defineVariable(new LoadPath(runtime, "$LOAD_PATH"));
-        
-        runtime.defineVariable(new MatchMatchGlobalVariable(runtime, "$&"));
-        runtime.defineVariable(new PreMatchGlobalVariable(runtime, "$`"));
-        runtime.defineVariable(new PostMatchGlobalVariable(runtime, "$'"));
-        runtime.defineVariable(new LastMatchGlobalVariable(runtime, "$+"));
-        runtime.defineVariable(new BackRefGlobalVariable(runtime, "$~"));
+        runtime.defineVariable(new LoadPath("$:"));
+        runtime.defineVariable(new LoadPath("$-I"));
+        runtime.defineVariable(new LoadPath("$LOAD_PATH"));
 
-        // On platforms without a c-library accessable through JNA, getpid will return hashCode 
+        runtime.defineVariable(new MatchMatchGlobalVariable("$&"));
+        runtime.defineVariable(new PreMatchGlobalVariable("$`"));
+        runtime.defineVariable(new PostMatchGlobalVariable("$'"));
+        runtime.defineVariable(new LastMatchGlobalVariable("$+"));
+        runtime.defineVariable(new BackRefGlobalVariable("$~"));
+
+        // On platforms without a c-library accessable through JNA, getpid will return hashCode
         // as $$ used to. Using $$ to kill processes could take down many runtimes, but by basing
         // $$ on getpid() where available, we have the same semantics as MRI.
-        runtime.getGlobalVariables().defineReadonly("$$", new ValueAccessor(runtime.newFixnum(runtime.getPosix().getpid())));
+        RubyFixnum pid = runtime.newFixnum(runtime.getPosix().getpid());
+        runtime.getGlobalVariables().defineReadonly("$$", new RuntimeVariableAccessor("$$", pid));
 
         // after defn of $stderr as the call may produce warnings
         defineGlobalEnvConstants(runtime);
-        
-        // Fixme: Do we need the check or does Main.java not call this...they should consolidate 
-        if (runtime.getGlobalVariables().get("$*").isNil()) {
-            runtime.getGlobalVariables().defineReadonly("$*", new ValueAccessor(runtime.newArray()));
-        }
-        
-        runtime.getGlobalVariables().defineReadonly("$-p", 
-                new ValueAccessor(runtime.getInstanceConfig().isAssumePrinting() ? runtime.getTrue() : runtime.getNil()));
-        runtime.getGlobalVariables().defineReadonly("$-n", 
-                new ValueAccessor(runtime.getInstanceConfig().isAssumeLoop() ? runtime.getTrue() : runtime.getNil()));
-        runtime.getGlobalVariables().defineReadonly("$-a", 
-                new ValueAccessor(runtime.getInstanceConfig().isSplit() ? runtime.getTrue() : runtime.getNil()));
-        runtime.getGlobalVariables().defineReadonly("$-l", 
-                new ValueAccessor(runtime.getInstanceConfig().isProcessLineEnds() ? runtime.getTrue() : runtime.getNil()));
 
+        IRubyObject assumePrinting = runtime.getInstanceConfig().isAssumePrinting() ? runtime.getTrue() : runtime.getNil();
+        runtime.getGlobalVariables().defineReadonly("$-p", new RuntimeVariableAccessor("$-p", assumePrinting));
+
+        IRubyObject assumeLoop = runtime.getInstanceConfig().isAssumeLoop() ? runtime.getTrue() : runtime.getNil();
+        runtime.getGlobalVariables().defineReadonly("$-n", new RuntimeVariableAccessor("$-n", assumeLoop));
+
+        IRubyObject split = runtime.getInstanceConfig().isSplit() ? runtime.getTrue() : runtime.getNil();
+        runtime.getGlobalVariables().defineReadonly("$-a", new RuntimeVariableAccessor("$-a", split));
+
+        IRubyObject processLineEnds = runtime.getInstanceConfig().isProcessLineEnds() ? runtime.getTrue() : runtime.getNil();
+        runtime.getGlobalVariables().defineReadonly("$-l", new RuntimeVariableAccessor("S-l", processLineEnds));
+
         // ARGF, $< object
         RubyArgsFile.initArgsFile(runtime);
     }
@@ -254,10 +251,10 @@
     	try {
     		environmentVariableMap = environment.getEnvironmentVariableMap(runtime);
     	} catch (OSEnvironmentReaderExcepton e) {
-    		// If the environment variables are not accessible shouldn't terminate 
+    		// If the environment variables are not accessible shouldn't terminate
     		runtime.getWarnings().warn(ID.MISCELLANEOUS, e.getMessage());
     	}
-		
+
     	if (environmentVariableMap == null) {
             // if the environment variables can't be obtained, define an empty ENV
     		environmentVariableMap = new HashMap();
@@ -272,103 +269,109 @@
         Map systemProps = environment.getSystemPropertiesMap(runtime);
         runtime.defineGlobalConstant("ENV_JAVA", new StringOnlyRubyHash(
                 runtime, systemProps, runtime.getNil()));
-        
+
     }
 
+    private static Ruby getRuntime() {
+        return Ruby.getCurrentRuntime();
+    }
+
     private static class NonEffectiveGlobalVariable extends GlobalVariable {
-        public NonEffectiveGlobalVariable(Ruby runtime, String name, IRubyObject value) {
-            super(runtime, name, value);
+        public NonEffectiveGlobalVariable(String name, IRubyObject value) {
+            super(name, value);
         }
 
         @Override
         public IRubyObject set(IRubyObject value) {
-            runtime.getWarnings().warn(ID.INEFFECTIVE_GLOBAL, "warning: variable " + name + " is no longer effective; ignored", name);
+            getRuntime().getWarnings().warn(ID.INEFFECTIVE_GLOBAL, "warning: variable " + name + " is no longer effective; ignored", name);
             return value;
         }
 
+
         @Override
         public IRubyObject get() {
-            runtime.getWarnings().warn(ID.INEFFECTIVE_GLOBAL, "warning: variable " + name + " is no longer effective", name);
-            return runtime.getFalse();
+            getRuntime().getWarnings().warn(ID.INEFFECTIVE_GLOBAL, "warning: variable " + name + " is no longer effective", name);
+            return getRuntime().getFalse();
         }
+
     }
 
     private static class LastExitStatusVariable extends GlobalVariable {
-        public LastExitStatusVariable(Ruby runtime, String name) {
-            super(runtime, name, runtime.getNil());
+        public LastExitStatusVariable(String name) {
+            super(name, getRuntime().getNil());
         }
-        
+
         @Override
         public IRubyObject get() {
-            IRubyObject lastExitStatus = runtime.getCurrentContext().getLastExitStatus();
-            return lastExitStatus == null ? runtime.getNil() : lastExitStatus;
+            IRubyObject lastExitStatus = getRuntime().getCurrentContext().getLastExitStatus();
+            return lastExitStatus == null ? getRuntime().getNil() : lastExitStatus;
         }
-        
+
         @Override
         public IRubyObject set(IRubyObject lastExitStatus) {
-            runtime.getCurrentContext().setLastExitStatus(lastExitStatus);
-            
+            getRuntime().getCurrentContext().setLastExitStatus(lastExitStatus);
+
             return lastExitStatus;
         }
     }
 
     private static class MatchMatchGlobalVariable extends GlobalVariable {
-        public MatchMatchGlobalVariable(Ruby runtime, String name) {
-            super(runtime, name, runtime.getNil());
+        public MatchMatchGlobalVariable(String name) {
+            super(name, getRuntime().getNil());
         }
-        
+
         @Override
         public IRubyObject get() {
-            return RubyRegexp.last_match(runtime.getCurrentContext().getCurrentFrame().getBackRef());
+            return RubyRegexp.last_match(getRuntime().getCurrentContext().getCurrentFrame().getBackRef());
         }
     }
 
     private static class PreMatchGlobalVariable extends GlobalVariable {
-        public PreMatchGlobalVariable(Ruby runtime, String name) {
-            super(runtime, name, runtime.getNil());
+        public PreMatchGlobalVariable(String name) {
+            super(name, getRuntime().getNil());
         }
-        
+
         @Override
         public IRubyObject get() {
-            return RubyRegexp.match_pre(runtime.getCurrentContext().getCurrentFrame().getBackRef());
+            return RubyRegexp.match_pre(getRuntime().getCurrentContext().getCurrentFrame().getBackRef());
         }
     }
 
     private static class PostMatchGlobalVariable extends GlobalVariable {
-        public PostMatchGlobalVariable(Ruby runtime, String name) {
-            super(runtime, name, runtime.getNil());
+        public PostMatchGlobalVariable(String name) {
+            super(name, getRuntime().getNil());
         }
-        
+
         @Override
         public IRubyObject get() {
-            return RubyRegexp.match_post(runtime.getCurrentContext().getCurrentFrame().getBackRef());
+            return RubyRegexp.match_post(getRuntime().getCurrentContext().getCurrentFrame().getBackRef());
         }
     }
 
     private static class LastMatchGlobalVariable extends GlobalVariable {
-        public LastMatchGlobalVariable(Ruby runtime, String name) {
-            super(runtime, name, runtime.getNil());
+        public LastMatchGlobalVariable(String name) {
+            super(name, getRuntime().getNil());
         }
-        
+
         @Override
         public IRubyObject get() {
-            return RubyRegexp.match_last(runtime.getCurrentContext().getCurrentFrame().getBackRef());
+            return RubyRegexp.match_last(getRuntime().getCurrentContext().getCurrentFrame().getBackRef());
         }
     }
 
     private static class BackRefGlobalVariable extends GlobalVariable {
-        public BackRefGlobalVariable(Ruby runtime, String name) {
-            super(runtime, name, runtime.getNil());
+        public BackRefGlobalVariable(String name) {
+            super(name, getRuntime().getNil());
         }
-        
+
         @Override
         public IRubyObject get() {
-            return RuntimeHelpers.getBackref(runtime, runtime.getCurrentContext());
+            return RuntimeHelpers.getBackref(getRuntime(), getRuntime().getCurrentContext());
         }
 
         @Override
         public IRubyObject set(IRubyObject value) {
-            RuntimeHelpers.setBackref(runtime, runtime.getCurrentContext(), value);
+            RuntimeHelpers.setBackref(getRuntime(), getRuntime().getCurrentContext(), value);
             return value;
         }
     }
@@ -376,113 +379,113 @@
     // Accessor methods.
 
     private static class LineNumberGlobalVariable extends GlobalVariable {
-        public LineNumberGlobalVariable(Ruby runtime, String name, RubyFixnum value) {
-            super(runtime, name, value);
+        public LineNumberGlobalVariable(String name, RubyFixnum value) {
+            super(name, value);
         }
 
         @Override
         public IRubyObject set(IRubyObject value) {
-            RubyArgsFile.setCurrentLineNumber(runtime.getGlobalVariables().get("$<"),RubyNumeric.fix2int(value));
+            RubyArgsFile.setCurrentLineNumber(getRuntime().getGlobalVariables().get("$<"),RubyNumeric.fix2int(value));
             return super.set(value);
         }
     }
 
     private static class ErrorInfoGlobalVariable extends GlobalVariable {
-        public ErrorInfoGlobalVariable(Ruby runtime, String name, IRubyObject value) {
-            super(runtime, name, null);
+        public ErrorInfoGlobalVariable(String name, IRubyObject value) {
+            super(name, null);
             set(value);
         }
 
         @Override
         public IRubyObject set(IRubyObject value) {
             if (!value.isNil() &&
-                    !runtime.getException().isInstance(value) &&
+                    !getRuntime().getException().isInstance(value) &&
                     !(JavaUtil.isJavaObject(value) && JavaUtil.unwrapJavaObject(value) instanceof Exception)) {
-                throw runtime.newTypeError("assigning non-exception to $!");
+                throw getRuntime().newTypeError("assigning non-exception to $!");
             }
-            
-            return runtime.getCurrentContext().setErrorInfo(value);
+
+            return getRuntime().getCurrentContext().setErrorInfo(value);
         }
 
         @Override
         public IRubyObject get() {
-            return runtime.getCurrentContext().getErrorInfo();
+            return getRuntime().getCurrentContext().getErrorInfo();
         }
     }
 
     // FIXME: move out of this class!
     public static class StringGlobalVariable extends GlobalVariable {
-        public StringGlobalVariable(Ruby runtime, String name, IRubyObject value) {
-            super(runtime, name, value);
+        public StringGlobalVariable(String name, IRubyObject value) {
+            super(name, value);
         }
 
         @Override
         public IRubyObject set(IRubyObject value) {
             if (!value.isNil() && ! (value instanceof RubyString)) {
-                throw runtime.newTypeError("value of " + name() + " must be a String");
+                throw getRuntime().newTypeError("value of " + name() + " must be a String");
             }
             return super.set(value);
         }
     }
 
     public static class KCodeGlobalVariable extends GlobalVariable {
-        public KCodeGlobalVariable(Ruby runtime, String name, IRubyObject value) {
-            super(runtime, name, value);
+        public KCodeGlobalVariable(String name, IRubyObject value) {
+            super(name, value);
         }
 
         @Override
         public IRubyObject get() {
-            return runtime.getKCode().kcode(runtime);
+            return getRuntime().getKCode().kcode(getRuntime());
         }
 
         @Override
         public IRubyObject set(IRubyObject value) {
-            runtime.setKCode(KCode.create(runtime, value.convertToString().toString()));
+            getRuntime().setKCode(KCode.create(getRuntime(), value.convertToString().toString()));
             return value;
         }
     }
 
     private static class SafeGlobalVariable extends GlobalVariable {
-        public SafeGlobalVariable(Ruby runtime, String name) {
-            super(runtime, name, null);
+        public SafeGlobalVariable(String name) {
+            super(name, null);
         }
 
         @Override
         public IRubyObject get() {
-            return runtime.newFixnum(runtime.getSafeLevel());
+            return getRuntime().newFixnum(getRuntime().getSafeLevel());
         }
 
         @Override
         public IRubyObject set(IRubyObject value) {
 //            int level = RubyNumeric.fix2int(value);
-//            if (level < runtime.getSafeLevel()) {
-//            	throw runtime.newSecurityError("tried to downgrade safe level from " + 
-//            			runtime.getSafeLevel() + " to " + level);
+//            if (level < getRuntime().getSafeLevel()) {
+//            	throw getRuntime().newSecurityError("tried to downgrade safe level from " +
+//            			getRuntime().getSafeLevel() + " to " + level);
 //            }
-//            runtime.setSafeLevel(level);
+//            getRuntime().setSafeLevel(level);
             // thread.setSafeLevel(level);
-            runtime.getWarnings().warn(ID.SAFE_NOT_SUPPORTED, "SAFE levels are not supported in JRuby");
-            return RubyFixnum.newFixnum(runtime, runtime.getSafeLevel());
+            getRuntime().getWarnings().warn(ID.SAFE_NOT_SUPPORTED, "SAFE levels are not supported in JRuby");
+            return RubyFixnum.newFixnum(getRuntime(), getRuntime().getSafeLevel());
         }
     }
 
     private static class VerboseGlobalVariable extends GlobalVariable {
-        public VerboseGlobalVariable(Ruby runtime, String name, IRubyObject initialValue) {
-            super(runtime, name, initialValue);
+        public VerboseGlobalVariable(String name, IRubyObject initialValue) {
+            super(name, initialValue);
             set(initialValue);
         }
-        
+
         @Override
         public IRubyObject get() {
-            return runtime.getVerbose();
+            return getRuntime().getVerbose();
         }
 
         @Override
         public IRubyObject set(IRubyObject newValue) {
             if (newValue.isNil()) {
-                runtime.setVerbose(newValue);
+                getRuntime().setVerbose(newValue);
             } else {
-                runtime.setVerbose(runtime.newBoolean(newValue.isTrue()));
+                getRuntime().setVerbose(getRuntime().newBoolean(newValue.isTrue()));
             }
 
             return newValue;
@@ -490,22 +493,22 @@
     }
 
     private static class DebugGlobalVariable extends GlobalVariable {
-        public DebugGlobalVariable(Ruby runtime, String name, IRubyObject initialValue) {
-            super(runtime, name, initialValue);
+        public DebugGlobalVariable(String name, IRubyObject initialValue) {
+            super(name, initialValue);
             set(initialValue);
         }
 
         @Override
         public IRubyObject get() {
-            return runtime.getDebug();
+            return getRuntime().getDebug();
         }
 
         @Override
         public IRubyObject set(IRubyObject newValue) {
             if (newValue.isNil()) {
-                runtime.setDebug(newValue);
+                getRuntime().setDebug(newValue);
             } else {
-                runtime.setDebug(runtime.newBoolean(newValue.isTrue()));
+                getRuntime().setDebug(getRuntime().newBoolean(newValue.isTrue()));
             }
 
             return newValue;
@@ -513,115 +516,103 @@
     }
 
     private static class BacktraceGlobalVariable extends GlobalVariable {
-        public BacktraceGlobalVariable(Ruby runtime, String name) {
-            super(runtime, name, null);
+        public BacktraceGlobalVariable(String name) {
+            super(name, null);
         }
 
         @Override
         public IRubyObject get() {
-            IRubyObject errorInfo = runtime.getGlobalVariables().get("$!");
-            IRubyObject backtrace = errorInfo.isNil() ? runtime.getNil() : errorInfo.callMethod(errorInfo.getRuntime().getCurrentContext(), "backtrace");
+            IRubyObject errorInfo = getRuntime().getGlobalVariables().get("$!");
+            IRubyObject backtrace = errorInfo.isNil() ? getRuntime().getNil() : errorInfo.callMethod(errorInfo.getRuntime().getCurrentContext(), "backtrace");
             //$@ returns nil if $!.backtrace is not an array
             if (!(backtrace instanceof RubyArray)) {
-                backtrace = runtime.getNil();
+                backtrace = getRuntime().getNil();
             }
             return backtrace;
         }
 
         @Override
         public IRubyObject set(IRubyObject value) {
-            if (runtime.getGlobalVariables().get("$!").isNil()) {
-                throw runtime.newArgumentError("$! not set.");
+            if (getRuntime().getGlobalVariables().get("$!").isNil()) {
+                throw getRuntime().newArgumentError("$! not set.");
             }
-            runtime.getGlobalVariables().get("$!").callMethod(value.getRuntime().getCurrentContext(), "set_backtrace", value);
+            getRuntime().getGlobalVariables().get("$!").callMethod(value.getRuntime().getCurrentContext(), "set_backtrace", value);
             return value;
         }
     }
 
     private static class LastlineGlobalVariable extends GlobalVariable {
-        public LastlineGlobalVariable(Ruby runtime, String name) {
-            super(runtime, name, null);
+        public LastlineGlobalVariable(String name) {
+            super(name, null);
         }
 
         @Override
         public IRubyObject get() {
-            return RuntimeHelpers.getLastLine(runtime, runtime.getCurrentContext());
+            return RuntimeHelpers.getLastLine(getRuntime(), getRuntime().getCurrentContext());
         }
 
         @Override
         public IRubyObject set(IRubyObject value) {
-            RuntimeHelpers.setLastLine(runtime, runtime.getCurrentContext(), value);
+            RuntimeHelpers.setLastLine(getRuntime(), getRuntime().getCurrentContext(), value);
             return value;
         }
     }
 
-    private static class InputGlobalVariable extends GlobalVariable {
-        public InputGlobalVariable(Ruby runtime, String name, IRubyObject value) {
-            super(runtime, name, value);
-        }
+    private static class RuntimeOutputAccessor extends RuntimeVariableAccessor {
+        private final String name;
 
-        @Override
-        public IRubyObject set(IRubyObject value) {
-            if (value == get()) {
-                return value;
-            }
-            
-            return super.set(value);
+        public RuntimeOutputAccessor(String name, IRubyObject value) {
+            super(name, value);
+            this.name = name;
         }
-    }
 
-    private static class OutputGlobalVariable extends GlobalVariable {
-        public OutputGlobalVariable(Ruby runtime, String name, IRubyObject value) {
-            super(runtime, name, value);
-        }
-
         @Override
-        public IRubyObject set(IRubyObject value) {
-            if (value == get()) {
-                return value;
+        public IRubyObject setValue(IRubyObject newValue) {
+            if (newValue == getValue()) {
+                return newValue;
             }
-            if (value instanceof RubyIO) {
-                RubyIO io = (RubyIO)value;
-                
+            if (newValue instanceof RubyIO) {
+                RubyIO io = (RubyIO)newValue;
+
                 // HACK: in order to have stdout/err act like ttys and flush always,
                 // we set anything assigned to stdout/stderr to sync
                 io.getHandler().setSync(true);
             }
 
-            if (!value.respondsTo("write")) {
-                throw runtime.newTypeError(name() + " must have write method, " +
-                                    value.getType().getName() + " given");
+            if (!newValue.respondsTo("write")) {
+                throw getRuntime().newTypeError(name + " must have write method, " +
+                                    newValue.getType().getName() + " given");
             }
 
-            return super.set(value);
+            return super.setValue(newValue);
         }
     }
 
     private static class LoadPath extends ReadonlyGlobalVariable {
-        public LoadPath(Ruby runtime, String name) {
-            super(runtime, name, null);
+        public LoadPath(String name) {
+            super(name, null);
         }
-        
+
         /**
          * @see org.jruby.runtime.GlobalVariable#get()
          */
         @Override
         public IRubyObject get() {
-            return runtime.getLoadService().getLoadPath();
+            return getRuntime().getLoadService().getLoadPath();
         }
     }
 
     private static class LoadedFeatures extends ReadonlyGlobalVariable {
-        public LoadedFeatures(Ruby runtime, String name) {
-            super(runtime, name, null);
+        public LoadedFeatures(String name) {
+            super(name, null);
         }
-        
+
         /**
          * @see org.jruby.runtime.GlobalVariable#get()
          */
         @Override
         public IRubyObject get() {
-            return runtime.getLoadService().getLoadedFeatures();
+            return getRuntime().getLoadService().getLoadedFeatures();
         }
     }
 }
Index: src/org/jruby/RubyClass.java
===================================================================
--- src/org/jruby/RubyClass.java	(revision 8091)
+++ src/org/jruby/RubyClass.java	(working copy)
@@ -54,6 +54,8 @@
 import org.jruby.runtime.marshal.MarshalStream;
 import org.jruby.runtime.marshal.UnmarshalStream;
 import org.jruby.util.collections.WeakHashSet;
+import org.jruby.util.RuntimeContainer;
+import org.jruby.util.JRubyClassLoader;
 
 /**
  *
@@ -74,7 +76,7 @@
     
     private CallSite[] extraCallSites;
     
-    public static void createClassClass(Ruby runtime, RubyClass classClass) {
+    public static void createClassClass(RubyClass classClass) {
         classClass.index = ClassIndex.CLASS;
         classClass.kindOf = new RubyModule.KindOf() {
             @Override
@@ -116,9 +118,9 @@
 
     @JRubyMethod(name = "allocate")
     public IRubyObject allocate() {
-        if (superClass == null) throw runtime.newTypeError("can't instantiate uninitialized class");
-        IRubyObject obj = allocator.allocate(runtime, this);
-        if (obj.getMetaClass().getRealClass() != getRealClass()) throw runtime.newTypeError("wrong instance allocation");
+        if (superClass == null) throw getRuntime().newTypeError("can't instantiate uninitialized class");
+        IRubyObject obj = allocator.allocate(getRuntime(), this);
+        if (obj.getMetaClass().getRealClass() != getRealClass()) throw getRuntime().newTypeError("wrong instance allocation");
         return obj;
     }
 
@@ -171,7 +173,6 @@
         return obj;
     }
 
-    private final Ruby runtime;
     private ObjectAllocator allocator; // the default allocator
     protected ObjectMarshal marshal;
     private Set<RubyClass> subclasses;
@@ -182,7 +183,6 @@
      */
     protected RubyClass(Ruby runtime, RubyClass superClass, boolean objectSpace) {
         super(runtime, runtime.getClassClass(), objectSpace);
-        this.runtime = runtime;
         this.superClass = superClass; // this is the only case it might be null here (in MetaClass construction)
     }
 
@@ -192,7 +192,6 @@
      */
     protected RubyClass(Ruby runtime, RubyClass superClass, Generation generation, boolean objectSpace) {
         super(runtime, runtime.getClassClass(), generation, objectSpace);
-        this.runtime = runtime;
         this.superClass = superClass; // this is the only case it might be null here (in MetaClass construction)
     }
     
@@ -201,7 +200,6 @@
      */
     protected RubyClass(Ruby runtime) {
         super(runtime, runtime.getClassClass());
-        this.runtime = runtime;
         index = ClassIndex.CLASS;
     }
     
@@ -624,7 +622,7 @@
     @JRubyMethod(name = "initialize_copy", required = 1, visibility = Visibility.PRIVATE)
     @Override
     public IRubyObject initialize_copy(IRubyObject original){
-        if (superClass != null) throw runtime.newTypeError("already initialized class");
+        if (superClass != null) throw getRuntime().newTypeError("already initialized class");
         if (original instanceof MetaClass) throw getRuntime().newTypeError("can't copy singleton class");        
         
         super.initialize_copy(original);
@@ -675,7 +673,7 @@
     }
     
     public Ruby getClassRuntime() {
-            return runtime;
+        return Ruby.getCurrentRuntime();
     }
 
     public RubyClass getRealClass() {
Index: src/org/jruby/RubyIO.java
===================================================================
--- src/org/jruby/RubyIO.java	(revision 8091)
+++ src/org/jruby/RubyIO.java	(working copy)
@@ -85,22 +85,22 @@
 import static org.jruby.RubyEnumerator.enumeratorize;
 
 /**
- * 
+ *
  * @author jpetersen
  */
 @JRubyClass(name="IO", include="Enumerable")
 public class RubyIO extends RubyObject {
     protected OpenFile openFile;
     protected List<RubyThread> blockingThreads;
-    
+
     public void registerDescriptor(ChannelDescriptor descriptor) {
         getRuntime().getDescriptors().put(new Integer(descriptor.getFileno()), new WeakReference<ChannelDescriptor>(descriptor));
     }
-    
+
     public void unregisterDescriptor(int aFileno) {
         getRuntime().getDescriptors().remove(new Integer(aFileno));
     }
-    
+
     public ChannelDescriptor getDescriptorByFileno(int aFileno) {
         Reference<ChannelDescriptor> reference = getRuntime().getDescriptors().get(new Integer(aFileno));
         if (reference == null) {
@@ -108,10 +108,10 @@
         }
         return reference.get();
     }
-    
+
     // FIXME can't use static; would interfere with other runtimes in the same JVM
     protected static AtomicInteger filenoIndex = new AtomicInteger(2);
-    
+
     public static int getNewFileno() {
         return filenoIndex.incrementAndGet();
     }
@@ -120,77 +120,77 @@
     // It allows this object to be created without a IOHandler.
     public RubyIO(Ruby runtime, RubyClass type) {
         super(runtime, type);
-        
+
         openFile = new OpenFile();
     }
 
     public RubyIO(Ruby runtime, OutputStream outputStream) {
         super(runtime, runtime.getIO());
-        
-        // We only want IO objects with valid streams (better to error now). 
+
+        // We only want IO objects with valid streams (better to error now).
         if (outputStream == null) {
             throw runtime.newRuntimeError("Opening null stream");
         }
-        
+
         openFile = new OpenFile();
-        
+
         try {
-            openFile.setMainStream(new ChannelStream(runtime, new ChannelDescriptor(Channels.newChannel(outputStream), getNewFileno(), new FileDescriptor())));
+            openFile.setMainStream(new ChannelStream(new ChannelDescriptor(Channels.newChannel(outputStream), getNewFileno(), new FileDescriptor())));
         } catch (InvalidValueException e) {
             throw getRuntime().newErrnoEINVALError();
         }
-        
+
         openFile.setMode(OpenFile.WRITABLE | OpenFile.APPEND);
-        
+
         registerDescriptor(openFile.getMainStream().getDescriptor());
     }
-    
+
     public RubyIO(Ruby runtime, InputStream inputStream) {
         super(runtime, runtime.getIO());
-        
+
         if (inputStream == null) {
             throw runtime.newRuntimeError("Opening null stream");
         }
-        
+
         openFile = new OpenFile();
-        
+
         try {
-            openFile.setMainStream(new ChannelStream(runtime, new ChannelDescriptor(Channels.newChannel(inputStream), getNewFileno(), new FileDescriptor())));
+            openFile.setMainStream(new ChannelStream(new ChannelDescriptor(Channels.newChannel(inputStream), getNewFileno(), new FileDescriptor())));
         } catch (InvalidValueException e) {
             throw getRuntime().newErrnoEINVALError();
         }
-        
+
         openFile.setMode(OpenFile.READABLE);
-        
+
         registerDescriptor(openFile.getMainStream().getDescriptor());
     }
-    
+
     public RubyIO(Ruby runtime, Channel channel) {
         super(runtime, runtime.getIO());
-        
-        // We only want IO objects with valid streams (better to error now). 
+
+        // We only want IO objects with valid streams (better to error now).
         if (channel == null) {
             throw runtime.newRuntimeError("Opening null channelpo");
         }
-        
+
         openFile = new OpenFile();
-        
+
         try {
-            openFile.setMainStream(new ChannelStream(runtime, new ChannelDescriptor(channel, getNewFileno(), new FileDescriptor())));
+            openFile.setMainStream(new ChannelStream(new ChannelDescriptor(channel, getNewFileno(), new FileDescriptor())));
         } catch (InvalidValueException e) {
             throw getRuntime().newErrnoEINVALError();
         }
-        
+
         openFile.setMode(openFile.getMainStream().getModes().getOpenFileFlags());
-        
+
         registerDescriptor(openFile.getMainStream().getDescriptor());
     }
 
     public RubyIO(Ruby runtime, ShellLauncher.POpenProcess process, ModeFlags modes) {
     	super(runtime, runtime.getIO());
-        
+
         openFile = new OpenFile();
-        
+
         openFile.setMode(modes.getOpenFileFlags() | OpenFile.SYNC);
         openFile.setProcess(process);
 
@@ -204,17 +204,17 @@
                     // Stream-based
                     inChannel = Channels.newChannel(process.getInputStream());
                 }
-                
+
                 ChannelDescriptor main = new ChannelDescriptor(
                         inChannel,
                         getNewFileno(),
                         new FileDescriptor());
                 main.setCanBeSeekable(false);
-                
-                openFile.setMainStream(new ChannelStream(getRuntime(), main));
+
+                openFile.setMainStream(new ChannelStream(main));
                 registerDescriptor(main);
             }
-            
+
             if (openFile.isWritable()) {
                 Channel outChannel;
                 if (process.getOutput() != null) {
@@ -229,23 +229,23 @@
                         getNewFileno(),
                         new FileDescriptor());
                 pipe.setCanBeSeekable(false);
-                
+
                 if (openFile.getMainStream() != null) {
-                    openFile.setPipeStream(new ChannelStream(getRuntime(), pipe));
+                    openFile.setPipeStream(new ChannelStream(pipe));
                 } else {
-                    openFile.setMainStream(new ChannelStream(getRuntime(), pipe));
+                    openFile.setMainStream(new ChannelStream(pipe));
                 }
-                
+
                 registerDescriptor(pipe);
             }
         } catch (InvalidValueException e) {
             throw getRuntime().newErrnoEINVALError();
         }
     }
-    
+
     public RubyIO(Ruby runtime, STDIO stdio) {
         super(runtime, runtime.getIO());
-        
+
         openFile = new OpenFile();
 
         try {
@@ -253,15 +253,13 @@
             case IN:
                 openFile.setMainStream(
                         new ChannelStream(
-                            runtime, 
                             // special constructor that accepts stream, not channel
-                            new ChannelDescriptor(runtime.getIn(), 0, new ModeFlags(ModeFlags.RDONLY), FileDescriptor.in),
+                            new ChannelDescriptor(Channels.newChannel(runtime.getIn()), 0, new ModeFlags(ModeFlags.RDONLY), FileDescriptor.in),
                             FileDescriptor.in));
                 break;
             case OUT:
                 openFile.setMainStream(
                         new ChannelStream(
-                            runtime, 
                             new ChannelDescriptor(Channels.newChannel(runtime.getOut()), 1, new ModeFlags(ModeFlags.WRONLY | ModeFlags.APPEND), FileDescriptor.out),
                             FileDescriptor.out));
                 openFile.getMainStream().setSync(true);
@@ -269,8 +267,7 @@
             case ERR:
                 openFile.setMainStream(
                         new ChannelStream(
-                            runtime, 
-                            new ChannelDescriptor(Channels.newChannel(runtime.getErr()), 2, new ModeFlags(ModeFlags.WRONLY | ModeFlags.APPEND), FileDescriptor.err), 
+                            new ChannelDescriptor(Channels.newChannel(runtime.getErr()), 2, new ModeFlags(ModeFlags.WRONLY | ModeFlags.APPEND), FileDescriptor.err),
                             FileDescriptor.err));
                 openFile.getMainStream().setSync(true);
                 break;
@@ -278,25 +275,25 @@
         } catch (InvalidValueException ex) {
             throw getRuntime().newErrnoEINVALError();
         }
-        
+
         openFile.setMode(openFile.getMainStream().getModes().getOpenFileFlags());
-        
-        registerDescriptor(openFile.getMainStream().getDescriptor());        
+
+        registerDescriptor(openFile.getMainStream().getDescriptor());
     }
-    
+
     public static RubyIO newIO(Ruby runtime, Channel channel) {
         return new RubyIO(runtime, channel);
     }
-    
+
     public OpenFile getOpenFile() {
         return openFile;
     }
-    
+
     protected OpenFile getOpenFileChecked() {
         openFile.checkClosed(getRuntime());
         return openFile;
     }
-    
+
     private static ObjectAllocator IO_ALLOCATOR = new ObjectAllocator() {
         public IRubyObject allocate(Ruby runtime, RubyClass klass) {
             return new RubyIO(runtime, klass);
@@ -313,12 +310,12 @@
         };
 
         ioClass.includeModule(runtime.getEnumerable());
-        
+
         // TODO: Implement tty? and isatty.  We have no real capability to
         // determine this from java, but if we could set tty status, then
         // we could invoke jruby differently to allow stdin to return true
         // on this.  This would allow things like cgi.rb to work properly.
-        
+
         ioClass.defineAnnotatedMethods(RubyIO.class);
 
         // Constants for seek
@@ -344,7 +341,7 @@
             return null;
         }
     }
-    
+
     public Stream getHandler() {
         return getOpenFileChecked().getMainStream();
     }
@@ -352,13 +349,13 @@
     @JRubyMethod(name = "reopen", required = 1, optional = 1)
     public IRubyObject reopen(ThreadContext context, IRubyObject[] args) throws InvalidValueException {
         Ruby runtime = context.getRuntime();
-        
+
     	if (args.length < 1) {
             throw runtime.newArgumentError("wrong number of arguments");
     	}
-    	
+
     	IRubyObject tmp = TypeConverter.convertToTypeWithCheck(args[0], runtime.getIO(), "to_io");
-        
+
     	if (!tmp.isNil()) {
             try {
                 RubyIO ios = (RubyIO) tmp;
@@ -399,10 +396,10 @@
                     // check if we're a stdio IO, and ensure we're not badly mutilated
                     if (selfDescriptor.getFileno() >=0 && selfDescriptor.getFileno() <= 2) {
                         selfFile.getMainStream().clearerr();
-                        
+
                         // dup2 new fd into self to preserve fileno and references to it
                         originalDescriptor.dup2Into(selfDescriptor);
-                        
+
                         // re-register, since fileno points at something new now
                         registerDescriptor(selfDescriptor);
                     } else {
@@ -422,22 +419,21 @@
                         } else {
                             selfFile.setMainStream(
                                     new ChannelStream(
-                                        runtime,
-                                        originalDescriptor.dup2(selfDescriptor.getFileno())));
-                            
+                                            originalDescriptor.dup2(selfDescriptor.getFileno())));
+
                             // re-register the descriptor
                             registerDescriptor(selfFile.getMainStream().getDescriptor());
-                            
+
                             // since we're not actually duping the incoming channel into our handler, we need to
                             // copy the original sync behavior from the other handler
                             selfFile.getMainStream().setSync(selfFile.getMainStream().isSync());
                         }
                         selfFile.setMode(mode);
                     }
-                    
+
                     // TODO: anything threads attached to original fd are notified of the close...
                     // see rb_thread_fd_close
-                    
+
                     if (originalFile.isReadable() && pos >= 0) {
                         selfFile.seek(pos, Stream.SEEK_SET);
                         originalFile.seek(pos, Stream.SEEK_SET);
@@ -446,7 +442,7 @@
 
                 if (selfFile.getPipeStream() != null && selfDescriptor.getFileno() != selfFile.getPipeStream().getDescriptor().getFileno()) {
                     int fd = selfFile.getPipeStream().getDescriptor().getFileno();
-                    
+
                     if (originalFile.getPipeStream() == null) {
                         selfFile.getPipeStream().fclose();
                         selfFile.setPipeStream(null);
@@ -454,17 +450,17 @@
                         selfFile.getPipeStream().fclose();
                         ChannelDescriptor newFD2 = originalFile.getPipeStream().getDescriptor().dup2(fd);
                         selfFile.setPipeStream(ChannelStream.fdopen(runtime, newFD2, getIOModes(runtime, "w")));
-                        
+
                         // re-register, since fileno points at something new now
                         registerDescriptor(newFD2);
                     }
                 }
-                
+
                 // TODO: restore binary mode
     //            if (fptr->mode & FMODE_BINMODE) {
     //                rb_io_binmode(io);
     //            }
-                
+
                 // TODO: set our metaclass to target's class (i.e. scary!)
 
             } catch (IOException ex) { // TODO: better error handling
@@ -476,13 +472,13 @@
             }
         } else {
             IRubyObject pathString = args[0].convertToString();
-            
+
             // TODO: check safe, taint on incoming string
-            
+
             if (openFile == null) {
                 openFile = new OpenFile();
             }
-            
+
             try {
                 ModeFlags modes;
                 if (args.length > 1) {
@@ -495,19 +491,19 @@
                 }
 
                 String path = pathString.toString();
-                
+
                 // Ruby code frequently uses a platform check to choose "NUL:" on windows
                 // but since that check doesn't work well on JRuby, we help it out
-                
+
                 openFile.setPath(path);
-            
+
                 if (openFile.getMainStream() == null) {
                     try {
                         openFile.setMainStream(ChannelStream.fopen(runtime, path, modes));
                     } catch (FileExistsException fee) {
                         throw runtime.newErrnoEEXISTError(path);
                     }
-                    
+
                     registerDescriptor(openFile.getMainStream().getDescriptor());
                     if (openFile.getPipeStream() != null) {
                         openFile.getPipeStream().fclose();
@@ -536,15 +532,15 @@
             	throw runtime.newErrnoEINVALError();
             }
         }
-        
+
         // A potentially previously close IO is being 'reopened'.
         return this;
     }
-    
+
     public static ModeFlags getIOModes(Ruby runtime, String modesString) throws InvalidValueException {
         return new ModeFlags(getIOModesIntFromString(runtime, modesString));
     }
-        
+
     public static int getIOModesIntFromString(Ruby runtime, String modesString) {
         int modes = 0;
         int length = modesString.length();
@@ -615,11 +611,11 @@
             boolean isParagraph = separator == Stream.PARAGRAPH_DELIMETER;
             separator = (separator == Stream.PARAGRAPH_DELIMETER) ?
                     Stream.PARAGRAPH_SEPARATOR : separator;
-            
+
             if (isParagraph) {
                 swallow('\n');
             }
-            
+
             if (separator == null) {
                 IRubyObject str = readAll(null);
                 if (((RubyString)str).getByteList().length() == 0) {
@@ -637,12 +633,12 @@
 
                 ByteList buf = new ByteList(0);
                 boolean update = false;
-                
+
                 while (true) {
                     do {
                         readCheck(readStream);
                         readStream.clearerr();
-                        
+
                         try {
                             n = readStream.getline(buf, (byte) newline);
                             c = buf.length() > 0 ? buf.get(buf.length() - 1) & 0xff : -1;
@@ -661,15 +657,15 @@
                                 break;
                             }
                         }
-            
+
                         update = true;
                     } while (c != newline); // loop until we see the nth separator char
-                    
+
                     // if we hit EOF, we're done
                     if (n == -1) {
                         break;
                     }
-                    
+
                     // if we've found the last char of the separator,
                     // and we've found at least as many characters as separator length,
                     // and the last n characters of our buffer match the separator, we're done
@@ -678,13 +674,13 @@
                         break;
                     }
                 }
-                
+
                 if (isParagraph) {
                     if (c != -1) {
                         swallow('\n');
                     }
                 }
-                
+
                 if (!update) {
                     return runtime.getNil();
                 } else {
@@ -719,25 +715,25 @@
     protected boolean swallow(int term) throws IOException, BadDescriptorException {
         Stream readStream = openFile.getMainStream();
         int c;
-        
+
         do {
             readCheck(readStream);
-            
+
             try {
                 c = readStream.fgetc();
             } catch (EOFException e) {
                 c = -1;
             }
-            
+
             if (c != term) {
                 readStream.ungetc(c);
                 return true;
             }
         } while (c != -1);
-        
+
         return false;
     }
-    
+
     public IRubyObject getlineFast(Ruby runtime, int delim) throws IOException, BadDescriptorException {
         Stream readStream = openFile.getMainStream();
         int c = -1;
@@ -754,7 +750,7 @@
             } catch (EOFException e) {
                 n = -1;
             }
-            
+
             if (n == -1) {
                 if (!readStream.isBlocking() && (readStream instanceof ChannelStream)) {
                     if(!(waitReadable(((ChannelStream)readStream).getDescriptor()))) {
@@ -765,7 +761,7 @@
                     break;
                 }
             }
-            
+
             update = true;
         } while (c != delim);
 
@@ -783,7 +779,7 @@
     @JRubyMethod(name = {"new", "for_fd"}, rest = true, frame = true, meta = true)
     public static IRubyObject newInstance(ThreadContext context, IRubyObject recv, IRubyObject[] args, Block block) {
         RubyClass klass = (RubyClass)recv;
-        
+
         if (block.isGiven()) {
             String className = klass.getName();
             context.getRuntime().getWarnings().warn(
@@ -791,7 +787,7 @@
                     className + "::new() does not take block; use " + className + "::open() instead",
                     className + "::open()");
         }
-        
+
         return klass.newInstance(context, args, block);
     }
 
@@ -799,18 +795,18 @@
     public IRubyObject initialize(IRubyObject[] args, Block unusedBlock) {
         int argCount = args.length;
         ModeFlags modes;
-        
+
         int fileno = RubyNumeric.fix2int(args[0]);
-        
+
         try {
             ChannelDescriptor descriptor = getDescriptorByFileno(fileno);
-            
+
             if (descriptor == null) {
                 throw getRuntime().newErrnoEBADFError();
             }
-            
+
             descriptor.checkOpen();
-            
+
             if (argCount == 2) {
                 if (args[1] instanceof RubyFixnum) {
                     modes = new ModeFlags(RubyFixnum.fix2long(args[1]));
@@ -823,35 +819,35 @@
             }
 
             openFile.setMode(modes.getOpenFileFlags());
-        
+
             openFile.setMainStream(fdopen(descriptor, modes));
         } catch (BadDescriptorException ex) {
             throw getRuntime().newErrnoEBADFError();
         } catch (InvalidValueException ive) {
             throw getRuntime().newErrnoEINVALError();
         }
-        
+
         return this;
     }
-    
+
     protected Stream fdopen(ChannelDescriptor existingDescriptor, ModeFlags modes) throws InvalidValueException {
         // See if we already have this descriptor open.
         // If so then we can mostly share the handler (keep open
         // file, but possibly change the mode).
-        
+
         if (existingDescriptor == null) {
             // redundant, done above as well
-            
+
             // this seems unlikely to happen unless it's a totally bogus fileno
             // ...so do we even need to bother trying to create one?
-            
+
             // IN FACT, we should probably raise an error, yes?
             throw getRuntime().newErrnoEBADFError();
-            
+
 //            if (mode == null) {
 //                mode = "r";
 //            }
-//            
+//
 //            try {
 //                openFile.setMainStream(streamForFileno(getRuntime(), fileno));
 //            } catch (BadDescriptorException e) {
@@ -860,7 +856,7 @@
 //                throw getRuntime().newErrnoEBADFError();
 //            }
 //            //modes = new IOModes(getRuntime(), mode);
-//            
+//
 //            registerStream(openFile.getMainStream());
         } else {
             // We are creating a new IO object that shares the same
@@ -873,7 +869,7 @@
     public static IRubyObject open(ThreadContext context, IRubyObject recv, IRubyObject[] args, Block block) {
         Ruby runtime = context.getRuntime();
         RubyClass klass = (RubyClass)recv;
-        
+
         RubyIO io = (RubyIO)klass.newInstance(context, args, block);
 
         if (block.isGiven()) {
@@ -901,48 +897,48 @@
     public IRubyObject binmode() {
             return this;
     }
-    
+
     /** @deprecated will be removed in 1.2 */
     protected void checkInitialized() {
         if (openFile == null) {
             throw getRuntime().newIOError("uninitialized stream");
         }
     }
-    
+
     /** @deprecated will be removed in 1.2 */
     protected void checkClosed() {
         if (openFile.getMainStream() == null && openFile.getPipeStream() == null) {
             throw getRuntime().newIOError("closed stream");
         }
     }
-    
+
     @JRubyMethod(name = "syswrite", required = 1)
     public IRubyObject syswrite(ThreadContext context, IRubyObject obj) {
         Ruby runtime = context.getRuntime();
-        
+
         try {
             RubyString string = obj.asString();
             OpenFile myOpenFile = getOpenFileChecked();
-            
+
             myOpenFile.checkWritable(runtime);
-            
+
             Stream writeStream = myOpenFile.getWriteStream();
-            
+
             if (myOpenFile.isWriteBuffered()) {
                 runtime.getWarnings().warn(ID.SYSWRITE_BUFFERED_IO, "syswrite for buffered IO");
             }
-            
+
             if (!writeStream.getDescriptor().isWritable()) {
                 myOpenFile.checkClosed(runtime);
             }
-            
+
             int read = writeStream.getDescriptor().write(string.getByteList());
-            
+
             if (read == -1) {
                 // TODO? I think this ends up propagating from normal Java exceptions
                 // sys_fail(openFile.getPath())
             }
-            
+
             return runtime.newFixnum(read);
         } catch (InvalidValueException ex) {
             throw runtime.newErrnoEINVALError();
@@ -954,7 +950,7 @@
             throw runtime.newSystemCallError(e.getMessage());
         }
     }
-    
+
     @JRubyMethod(name = "write_nonblock", required = 1)
     public IRubyObject write_nonblock(ThreadContext context, IRubyObject obj) {
         // MRI behavior: always check whether the file is writable
@@ -983,27 +979,27 @@
             throw context.getRuntime().newErrnoEPIPEError();
         }
     }
-    
+
     /** io_write
-     * 
+     *
      */
     @JRubyMethod(name = "write", required = 1)
     public IRubyObject write(ThreadContext context, IRubyObject obj) {
         Ruby runtime = context.getRuntime();
-        
+
         runtime.secure(4);
-        
+
         RubyString str = obj.asString();
 
         // TODO: Ruby reuses this logic for other "write" behavior by checking if it's an IO and calling write again
-        
+
         if (str.getByteList().length() == 0) {
             return runtime.newFixnum(0);
         }
 
         try {
             OpenFile myOpenFile = getOpenFileChecked();
-            
+
             myOpenFile.checkWritable(runtime);
 
             int written = fwrite(str.getByteList());
@@ -1034,13 +1030,13 @@
         if (channel == null || !(channel instanceof SelectableChannel)) {
             return false;
         }
-       
+
         Selector selector = Selector.open();
 
         ((SelectableChannel) channel).configureBlocking(false);
         int real_ops = ((SelectableChannel) channel).validOps() & SelectionKey.OP_WRITE;
         SelectionKey key = ((SelectableChannel) channel).keyFor(selector);
-       
+
         if (key == null) {
             ((SelectableChannel) channel).register(selector, real_ops, descriptor);
         } else {
@@ -1065,13 +1061,13 @@
         if (channel == null || !(channel instanceof SelectableChannel)) {
             return false;
         }
-       
+
         Selector selector = Selector.open();
 
         ((SelectableChannel) channel).configureBlocking(false);
         int real_ops = ((SelectableChannel) channel).validOps() & (SelectionKey.OP_READ | SelectionKey.OP_ACCEPT);
         SelectionKey key = ((SelectableChannel) channel).keyFor(selector);
-       
+
         if (key == null) {
             ((SelectableChannel) channel).register(selector, real_ops, descriptor);
         } else {
@@ -1090,14 +1086,14 @@
         }
         return false;
     }
-    
+
     protected int fwrite(ByteList buffer) {
         int n, r, l, offset = 0;
         boolean eagain = false;
         Stream writeStream = openFile.getWriteStream();
 
         int len = buffer.length();
-        
+
         if ((n = len) <= 0) return n;
 
         try {
@@ -1108,7 +1104,7 @@
     //            if (!rb_thread_fd_writable(fileno(f))) {
     //                rb_io_check_closed(fptr);
     //            }
-               
+
                 while(offset<len) {
                     l = n;
 
@@ -1188,23 +1184,23 @@
     }
 
     /** rb_io_addstr
-     * 
+     *
      */
     @JRubyMethod(name = "<<", required = 1)
     public IRubyObject op_append(ThreadContext context, IRubyObject anObject) {
         // Claims conversion is done via 'to_s' in docs.
         callMethod(context, "write", anObject);
-        
-        return this; 
+
+        return this;
     }
 
     @JRubyMethod(name = "fileno", alias = "to_i")
     public RubyFixnum fileno(ThreadContext context) {
         return context.getRuntime().newFixnum(getOpenFileChecked().getMainStream().getDescriptor().getFileno());
     }
-    
+
     /** Returns the current line number.
-     * 
+     *
      * @return the current line number.
      */
     @JRubyMethod(name = "lineno")
@@ -1213,7 +1209,7 @@
     }
 
     /** Sets the current line number.
-     * 
+     *
      * @param newLineNumber The new line number.
      */
     @JRubyMethod(name = "lineno=", required = 1)
@@ -1224,36 +1220,36 @@
     }
 
     /** Returns the current sync mode.
-     * 
+     *
      * @return the current sync mode.
      */
     @JRubyMethod(name = "sync")
     public RubyBoolean sync(ThreadContext context) {
         return context.getRuntime().newBoolean(getOpenFileChecked().getMainStream().isSync());
     }
-    
+
     /**
      * <p>Return the process id (pid) of the process this IO object
      * spawned.  If no process exists (popen was not called), then
      * nil is returned.  This is not how it appears to be defined
      * but ruby 1.8 works this way.</p>
-     * 
+     *
      * @return the pid or nil
      */
     @JRubyMethod(name = "pid")
     public IRubyObject pid(ThreadContext context) {
         OpenFile myOpenFile = getOpenFileChecked();
-        
+
         if (myOpenFile.getProcess() == null) {
             return context.getRuntime().getNil();
         }
-        
+
         // Of course this isn't particularly useful.
         int pid = myOpenFile.getProcess().hashCode();
-        
-        return context.getRuntime().newFixnum(pid); 
+
+        return context.getRuntime().newFixnum(pid);
     }
-    
+
     /**
      * @deprecated
      * @return
@@ -1261,7 +1257,7 @@
     public boolean writeDataBuffered() {
         return openFile.getMainStream().writeDataBuffered();
     }
-    
+
     @JRubyMethod(name = {"pos", "tell"})
     public RubyFixnum pos(ThreadContext context) {
         try {
@@ -1276,7 +1272,7 @@
             throw context.getRuntime().newIOError(e.getMessage());
         }
     }
-    
+
     @JRubyMethod(name = "pos=", required = 1)
     public RubyFixnum pos_set(ThreadContext context, IRubyObject newPosition) {
         long offset = RubyNumeric.num2long(newPosition);
@@ -1284,9 +1280,9 @@
         if (offset < 0) {
             throw context.getRuntime().newSystemCallError("Negative seek offset");
         }
-        
+
         OpenFile myOpenFile = getOpenFileChecked();
-        
+
         try {
             myOpenFile.getMainStream().lseek(offset, Stream.SEEK_SET);
         } catch (BadDescriptorException e) {
@@ -1298,14 +1294,14 @@
         } catch (IOException e) {
             throw context.getRuntime().newIOError(e.getMessage());
         }
-        
+
         myOpenFile.getMainStream().clearerr();
-        
+
         return context.getRuntime().newFixnum(offset);
     }
-    
+
     /** Print some objects to the stream.
-     * 
+     *
      */
     @JRubyMethod(name = "print", rest = true, reads = FrameField.LASTLINE)
     public IRubyObject print(ThreadContext context, IRubyObject[] args) {
@@ -1316,7 +1312,7 @@
         Ruby runtime = context.getRuntime();
         IRubyObject fs = runtime.getGlobalVariables().get("$,");
         IRubyObject rs = runtime.getGlobalVariables().get("$\\");
-        
+
         for (int i = 0; i < args.length; i++) {
             if (i > 0 && !fs.isNil()) {
                 callMethod(context, "write", fs);
@@ -1344,7 +1340,7 @@
     public IRubyObject putc(ThreadContext context, IRubyObject object) {
 
         try {
-            OpenFile myOpenFile = getOpenFileChecked();            
+            OpenFile myOpenFile = getOpenFileChecked();
             myOpenFile.checkWritable(context.getRuntime());
             Stream writeStream = myOpenFile.getWriteStream();
             writeStream.fputc(RubyNumeric.num2chr(object));
@@ -1365,11 +1361,11 @@
     public RubyFixnum seek(ThreadContext context, IRubyObject[] args) {
         long offset = RubyNumeric.num2long(args[0]);
         int whence = Stream.SEEK_SET;
-        
+
         if (args.length > 1) {
             whence = RubyNumeric.fix2int(args[1].convertToInteger());
         }
-        
+
         return doSeek(context, offset, whence);
     }
 
@@ -1377,7 +1373,7 @@
     public RubyFixnum seek(ThreadContext context, IRubyObject arg0) {
         long offset = RubyNumeric.num2long(arg0);
         int whence = Stream.SEEK_SET;
-        
+
         return doSeek(context, offset, whence);
     }
 
@@ -1385,13 +1381,13 @@
     public RubyFixnum seek(ThreadContext context, IRubyObject arg0, IRubyObject arg1) {
         long offset = RubyNumeric.num2long(arg0);
         int whence = RubyNumeric.fix2int(arg1.convertToInteger());
-        
+
         return doSeek(context, offset, whence);
     }
-    
+
     private RubyFixnum doSeek(ThreadContext context, long offset, int whence) {
         OpenFile myOpenFile = getOpenFileChecked();
-        
+
         try {
             myOpenFile.seek(offset, whence);
         } catch (BadDescriptorException ex) {
@@ -1403,12 +1399,12 @@
         } catch (IOException e) {
             throw context.getRuntime().newIOError(e.getMessage());
         }
-        
+
         myOpenFile.getMainStream().clearerr();
-        
+
         return RubyFixnum.zero(context.getRuntime());
     }
-    
+
     // This was a getOpt with one mandatory arg, but it did not work
     // so I am parsing it for now.
     @JRubyMethod(name = "sysseek", required = 1, optional = 1)
@@ -1416,22 +1412,22 @@
         long offset = RubyNumeric.num2long(args[0]);
         long pos;
         int whence = Stream.SEEK_SET;
-        
+
         if (args.length > 1) {
             whence = RubyNumeric.fix2int(args[1].convertToInteger());
         }
-        
+
         OpenFile myOpenFile = getOpenFileChecked();
-        
+
         try {
-            
+
             if (myOpenFile.isReadable() && myOpenFile.isReadBuffered()) {
                 throw context.getRuntime().newIOError("sysseek for buffered IO");
             }
             if (myOpenFile.isWritable() && myOpenFile.isWriteBuffered()) {
                 context.getRuntime().getWarnings().warn(ID.SYSSEEK_BUFFERED_IO, "sysseek for buffered IO");
             }
-            
+
             pos = myOpenFile.getMainStream().getDescriptor().lseek(offset, whence);
         } catch (BadDescriptorException ex) {
             throw context.getRuntime().newErrnoEBADFError();
@@ -1442,20 +1438,20 @@
         } catch (IOException e) {
             throw context.getRuntime().newIOError(e.getMessage());
         }
-        
+
         myOpenFile.getMainStream().clearerr();
-        
+
         return context.getRuntime().newFixnum(pos);
     }
 
     @JRubyMethod(name = "rewind")
     public RubyFixnum rewind(ThreadContext context) {
         OpenFile myOpenfile = getOpenFileChecked();
-        
+
         try {
             myOpenfile.getMainStream().lseek(0L, Stream.SEEK_SET);
             myOpenfile.getMainStream().clearerr();
-            
+
             // TODO: This is some goofy global file value from MRI..what to do?
 //            if (io == current_file) {
 //                gets_lineno -= fptr->lineno;
@@ -1472,19 +1468,19 @@
 
         // Must be back on first line on rewind.
         myOpenfile.setLineNumber(0);
-        
+
         return RubyFixnum.zero(context.getRuntime());
     }
-    
+
     @JRubyMethod(name = "fsync")
     public RubyFixnum fsync(ThreadContext context) {
         Ruby runtime = context.getRuntime();
-        
+
         try {
             OpenFile myOpenFile = getOpenFileChecked();
-            
+
             myOpenFile.checkWritable(runtime);
-        
+
             myOpenFile.getWriteStream().sync();
         } catch (InvalidValueException ex) {
             throw runtime.newErrnoEINVALError();
@@ -1500,7 +1496,7 @@
     }
 
     /** Sets the current sync mode.
-     * 
+     *
      * @param newSync The new sync mode.
      */
     @JRubyMethod(name = "sync=", required = 1)
@@ -1514,7 +1510,7 @@
     @JRubyMethod(name = {"eof?", "eof"})
     public RubyBoolean eof_p(ThreadContext context) {
         Ruby runtime = context.getRuntime();
-        
+
         try {
             OpenFile myOpenFile = getOpenFileChecked();
 
@@ -1524,26 +1520,26 @@
             if (myOpenFile.getMainStream().feof()) {
                 return runtime.getTrue();
             }
-            
+
             if (myOpenFile.getMainStream().readDataBuffered()) {
                 return runtime.getFalse();
             }
-            
+
             readCheck(myOpenFile.getMainStream());
-            
+
             myOpenFile.getMainStream().clearerr();
-            
+
             int c = myOpenFile.getMainStream().fgetc();
-            
+
             if (c != -1) {
                 myOpenFile.getMainStream().ungetc(c);
                 return runtime.getFalse();
             }
-            
+
             myOpenFile.checkClosed(runtime);
-            
+
             myOpenFile.getMainStream().clearerr();
-            
+
             return runtime.getTrue();
         } catch (PipeException ex) {
             throw runtime.newErrnoEPIPEError();
@@ -1560,23 +1556,23 @@
     public RubyBoolean tty_p(ThreadContext context) {
         return context.getRuntime().newBoolean(context.getRuntime().getPosix().isatty(getOpenFileChecked().getMainStream().getDescriptor().getFileDescriptor()));
     }
-    
+
     @JRubyMethod(name = "initialize_copy", required = 1)
     @Override
     public IRubyObject initialize_copy(IRubyObject original){
         Ruby runtime = getRuntime();
-        
+
         if (this == original) return this;
 
         RubyIO originalIO = (RubyIO) TypeConverter.convertToTypeWithCheck(original, runtime.getIO(), "to_io");
-        
+
         OpenFile originalFile = originalIO.getOpenFileChecked();
         OpenFile newFile = openFile;
-        
+
         try {
             // TODO: I didn't see where MRI has this check, but it seems to be the right place
             originalFile.checkClosed(runtime);
-            
+
             if (originalFile.getPipeStream() != null) {
                 originalFile.getPipeStream().fflush();
                 originalFile.getMainStream().lseek(0, Stream.SEEK_CUR);
@@ -1591,7 +1587,7 @@
             newFile.setLineNumber(originalFile.getLineNumber());
             newFile.setPath(originalFile.getPath());
             newFile.setFinalizer(originalFile.getFinalizer());
-            
+
             ModeFlags modes;
             if (newFile.isReadable()) {
                 if (newFile.isWritable()) {
@@ -1610,14 +1606,14 @@
                     modes = originalFile.getMainStream().getModes();
                 }
             }
-            
+
             ChannelDescriptor descriptor = originalFile.getMainStream().getDescriptor().dup();
 
             newFile.setMainStream(ChannelStream.fdopen(runtime, descriptor, modes));
-            
+
             // TODO: the rest of this...seeking to same position is unnecessary since we share a channel
             // but some of this may be needed?
-            
+
 //    fseeko(fptr->f, ftello(orig->f), SEEK_SET);
 //    if (orig->f2) {
 //	if (fileno(orig->f) != fileno(orig->f2)) {
@@ -1629,7 +1625,7 @@
 //    if (fptr->mode & FMODE_BINMODE) {
 //	rb_io_binmode(dest);
 //    }
-            
+
             // Register the new descriptor
             registerDescriptor(newFile.getMainStream().getDescriptor());
         } catch (IOException ex) {
@@ -1641,12 +1637,12 @@
         } catch (InvalidValueException ex) {
             throw runtime.newIOError("could not init copy: " + ex);
         }
-        
+
         return this;
     }
-    
+
     /** Closes the IO.
-     * 
+     *
      * @return The IO.
      */
     @JRubyMethod(name = "closed?")
@@ -1654,30 +1650,30 @@
         return context.getRuntime().newBoolean(openFile.getMainStream() == null && openFile.getPipeStream() == null);
     }
 
-    /** 
+    /**
      * <p>Closes all open resources for the IO.  It also removes
      * it from our magical all open file descriptor pool.</p>
-     * 
+     *
      * @return The IO.
      */
     @JRubyMethod(name = "close")
     public IRubyObject close() {
         Ruby runtime = getRuntime();
-        
+
         if (runtime.getSafeLevel() >= 4 && isTaint()) {
             throw runtime.newSecurityError("Insecure: can't close");
         }
-        
+
         openFile.checkClosed(runtime);
         return close2(runtime);
     }
-        
+
     protected IRubyObject close2(Ruby runtime) {
         if (openFile == null) return runtime.getNil();
-        
+
         // These would be used when we notify threads...if we notify threads
         interruptBlockingThreads();
-        
+
         ChannelDescriptor main, pipe;
         if (openFile.getPipeStream() != null) {
             pipe = openFile.getPipeStream().getDescriptor();
@@ -1687,14 +1683,14 @@
             }
             pipe = null;
         }
-        
+
         main = openFile.getMainStream().getDescriptor();
-        
+
         // cleanup, raising errors if any
         openFile.cleanup(runtime, true);
-        
+
         // TODO: notify threads waiting on descriptors/IO? probably not...
-        
+
         if (openFile.getProcess() != null) {
             try {
                 IRubyObject processResult = RubyProcess.RubyStatus.newProcessStatus(runtime, openFile.getProcess().waitFor());
@@ -1703,7 +1699,7 @@
                 // TODO: do something here?
             }
         }
-        
+
         return runtime.getNil();
     }
 
@@ -1713,13 +1709,13 @@
             if (context.getRuntime().getSafeLevel() >= 4 && isTaint()) {
                 throw context.getRuntime().newSecurityError("Insecure: can't close");
             }
-            
+
             OpenFile myOpenFile = getOpenFileChecked();
-            
+
             if (myOpenFile.getPipeStream() == null && myOpenFile.isReadable()) {
                 throw context.getRuntime().newIOError("closing non-duplex IO for writing");
             }
-            
+
             if (myOpenFile.getPipeStream() == null) {
                 close();
             } else{
@@ -1739,18 +1735,18 @@
     @JRubyMethod(name = "close_read")
     public IRubyObject close_read(ThreadContext context) throws BadDescriptorException {
         Ruby runtime = context.getRuntime();
-        
+
         try {
             if (runtime.getSafeLevel() >= 4 && isTaint()) {
                 throw runtime.newSecurityError("Insecure: can't close");
             }
-            
+
             OpenFile myOpenFile = getOpenFileChecked();
-            
+
             if (myOpenFile.getPipeStream() == null && myOpenFile.isWritable()) {
                 throw runtime.newIOError("closing non-duplex IO for reading");
             }
-            
+
             if (myOpenFile.getPipeStream() == null) {
                 close();
             } else{
@@ -1770,12 +1766,12 @@
     }
 
     /** Flushes the IO output stream.
-     * 
+     *
      * @return The IO.
      */
     @JRubyMethod(name = "flush")
     public RubyIO flush() {
-        try { 
+        try {
             getOpenFileChecked().getWriteStream().fflush();
         } catch (BadDescriptorException e) {
             throw getRuntime().newErrnoEBADFError();
@@ -1787,13 +1783,13 @@
     }
 
     /** Read a line.
-     * 
+     *
      */
     @JRubyMethod(name = "gets", optional = 1, writes = FrameField.LASTLINE)
     public IRubyObject gets(ThreadContext context, IRubyObject[] args) {
         Ruby runtime = context.getRuntime();
         ByteList separator = getSeparatorForGets(runtime, args);
-        
+
         IRubyObject result = getline(runtime, separator);
 
         if (!result.isNil()) context.getCurrentFrame().setLastLine(result);
@@ -1816,21 +1812,21 @@
     public IRubyObject ioctl(ThreadContext context, IRubyObject[] args) {
         IRubyObject cmd = args[0];
         IRubyObject arg;
-        
+
         if (args.length == 2) {
             arg = args[1];
         } else {
             arg = context.getRuntime().getNil();
         }
-        
+
         return ctl(context.getRuntime(), cmd, arg);
     }
 
     public IRubyObject ctl(Ruby runtime, IRubyObject cmd, IRubyObject arg) {
         long realCmd = cmd.convertToInteger().getLongValue();
         long nArg = 0;
-        
-        // FIXME: Arg may also be true, false, and nil and still be valid.  Strangely enough, 
+
+        // FIXME: Arg may also be true, false, and nil and still be valid.  Strangely enough,
         // protocol conversion is not happening in Ruby on this arg?
         if (arg.isNil() || arg == runtime.getFalse()) {
             nArg = 0;
@@ -1841,13 +1837,13 @@
         } else {
             throw runtime.newNotImplementedError("JRuby does not support string for second fcntl/ioctl argument yet");
         }
-        
+
         OpenFile myOpenFile = getOpenFileChecked();
 
         // Fixme: Only F_SETFL is current supported
         if (realCmd == 1L) {  // cmd is F_SETFL
             boolean block = true;
-            
+
             if ((nArg & ModeFlags.NONBLOCK) == ModeFlags.NONBLOCK) {
                 block = false;
             }
@@ -1860,10 +1856,10 @@
         } else {
             throw runtime.newNotImplementedError("JRuby only supports F_SETFL for fcntl/ioctl currently");
         }
-        
+
         return runtime.newFixnum(0);
     }
-    
+
     private static final ByteList NIL_BYTELIST = ByteList.create("nil");
     private static final ByteList RECURSIVE_BYTELIST = ByteList.create("[...]");
 
@@ -1872,7 +1868,7 @@
         Ruby runtime = context.getRuntime();
         assert runtime.getGlobalVariables().getDefaultSeparator() instanceof RubyString;
         RubyString separator = (RubyString) runtime.getGlobalVariables().getDefaultSeparator();
-        
+
         if (args.length == 0) {
             write(context, separator.getByteList());
             return runtime.getNil();
@@ -1880,7 +1876,7 @@
 
         for (int i = 0; i < args.length; i++) {
             ByteList line;
-            
+
             if (args[i].isNil()) {
                 line = NIL_BYTELIST;
             } else if (runtime.isInspecting(args[i])) {
@@ -1891,9 +1887,9 @@
             } else {
                 line = args[i].asString().getByteList();
             }
-            
+
             write(context, line);
-            
+
             if (line.length() == 0 || !line.endsWith(separator.getByteList())) {
                 write(context, separator.getByteList());
             }
@@ -1915,19 +1911,19 @@
     }
 
     /** Read a line.
-     * 
+     *
      */
     @JRubyMethod(name = "readline", optional = 1, writes = FrameField.LASTLINE)
     public IRubyObject readline(ThreadContext context, IRubyObject[] args) {
         IRubyObject line = gets(context, args);
 
         if (line.isNil()) throw context.getRuntime().newEOFError();
-        
+
         return line;
     }
 
     /** Read a byte. On EOF returns nil.
-     * 
+     *
      */
     @JRubyMethod(name = "getc")
     public IRubyObject getc() {
@@ -1938,12 +1934,12 @@
             myOpenFile.setReadBuffered();
 
             Stream stream = myOpenFile.getMainStream();
-            
+
             readCheck(stream);
             stream.clearerr();
-        
+
             int c = myOpenFile.getMainStream().fgetc();
-            
+
             if (c == -1) {
                 // TODO: check for ferror, clear it, and try once more up above readCheck
 //                if (ferror(f)) {
@@ -1954,7 +1950,7 @@
 //                }
                 return getRuntime().getNil();
             }
-        
+
             return getRuntime().newFixnum(c);
         } catch (PipeException ex) {
             throw getRuntime().newErrnoEPIPEError();
@@ -1968,28 +1964,28 @@
             throw getRuntime().newIOError(e.getMessage());
         }
     }
-    
+
     private void readCheck(Stream stream) {
         if (!stream.readDataBuffered()) {
             openFile.checkClosed(getRuntime());
         }
     }
-    
-    /** 
+
+    /**
      * <p>Pushes char represented by int back onto IOS.</p>
-     * 
+     *
      * @param number to push back
      */
     @JRubyMethod(name = "ungetc", required = 1)
     public IRubyObject ungetc(IRubyObject number) {
         int ch = RubyNumeric.fix2int(number);
-        
+
         OpenFile myOpenFile = getOpenFileChecked();
-        
+
         if (!myOpenFile.isReadBuffered()) {
             throw getRuntime().newIOError("unread stream");
         }
-        
+
         try {
             myOpenFile.checkReadable(getRuntime());
             myOpenFile.setReadBuffered();
@@ -2011,7 +2007,7 @@
 
         return getRuntime().getNil();
     }
-    
+
     @JRubyMethod(name = "read_nonblock", required = 1, optional = 1)
     public IRubyObject read_nonblock(ThreadContext context, IRubyObject[] args) {
         Ruby runtime = context.getRuntime();
@@ -2043,7 +2039,7 @@
             throw runtime.newIOError(e.getMessage());
         }
     }
-    
+
     @JRubyMethod(name = "readpartial", required = 1, optional = 1)
     public IRubyObject readpartial(ThreadContext context, IRubyObject[] args) {
         Ruby runtime = context.getRuntime();
@@ -2088,48 +2084,48 @@
                 if (len == 0) {
                     return RubyString.newEmptyString(getRuntime());
                 }
-                
+
                 buffer = new ByteList(len);
                 str = RubyString.newString(getRuntime(), buffer);
             } else {
                 str = args[1].convertToString();
                 str.modify(len);
-                
+
                 if (len == 0) {
                     return str;
                 }
-                
+
                 buffer = str.getByteList();
                 buffer.length(0);
             }
-            
+
             OpenFile myOpenFile = getOpenFileChecked();
-            
+
             myOpenFile.checkReadable(getRuntime());
-            
+
             if (myOpenFile.getMainStream().readDataBuffered()) {
                 throw getRuntime().newIOError("sysread for buffered IO");
             }
-            
+
             // TODO: Ruby locks the string here
-            
+
             context.getThread().beforeBlockingCall();
             myOpenFile.checkClosed(getRuntime());
-            
+
             // TODO: Ruby re-checks that the buffer string hasn't been modified
-            
+
             int bytesRead = myOpenFile.getMainStream().getDescriptor().read(len, str.getByteList());
-            
+
             // TODO: Ruby unlocks the string here
-            
+
             // TODO: Ruby truncates string to specific size here, but our bytelist should handle this already?
-            
+
             if (bytesRead == -1 || (bytesRead == 0 && len > 0)) {
                 throw getRuntime().newEOFError();
             }
-            
+
             str.setTaint(true);
-            
+
             return str;
         } catch (BadDescriptorException e) {
             throw getRuntime().newErrnoEBADFError();
@@ -2151,10 +2147,10 @@
             context.getThread().afterBlockingCall();
         }
     }
-    
+
     public IRubyObject read(IRubyObject[] args) {
         ThreadContext context = getRuntime().getCurrentContext();
-        
+
         switch (args.length) {
         case 0: return read(context);
         case 1: return read(context, args[0]);
@@ -2162,12 +2158,12 @@
         default: throw getRuntime().newArgumentError(args.length, 2);
         }
     }
-    
+
     @JRubyMethod(name = "read")
     public IRubyObject read(ThreadContext context) {
         Ruby runtime = context.getRuntime();
         OpenFile myOpenFile = getOpenFileChecked();
-        
+
         try {
             myOpenFile.checkReadable(runtime);
             myOpenFile.setReadBuffered();
@@ -2185,30 +2181,30 @@
             throw getRuntime().newErrnoEBADFError();
         }
     }
-    
+
     @JRubyMethod(name = "read")
     public IRubyObject read(ThreadContext context, IRubyObject arg0) {
         if (arg0.isNil()) {
             return read(context);
         }
-        
+
         OpenFile myOpenFile = getOpenFileChecked();
-        
+
         int length = RubyNumeric.num2int(arg0);
-        
+
         if (length < 0) {
             throw getRuntime().newArgumentError("negative length " + length + " given");
         }
-        
+
         RubyString str = null;
 
         return readNotAll(context, myOpenFile, length, str);
     }
-    
+
     @JRubyMethod(name = "read")
     public IRubyObject read(ThreadContext context, IRubyObject arg0, IRubyObject arg1) {
         OpenFile myOpenFile = getOpenFileChecked();
-        
+
         if (arg0.isNil()) {
             try {
                 myOpenFile.checkReadable(getRuntime());
@@ -2227,13 +2223,13 @@
                 throw getRuntime().newErrnoEBADFError();
             }
         }
-        
+
         int length = RubyNumeric.num2int(arg0);
-        
+
         if (length < 0) {
             throw getRuntime().newArgumentError("negative length " + length + " given");
         }
-        
+
         RubyString str = null;
 //        ByteList buffer = null;
         if (arg1.isNil()) {
@@ -2249,13 +2245,13 @@
 
 //            buffer = str.getByteList();
         }
-        
+
         return readNotAll(context, myOpenFile, length, str);
     }
-    
+
     private IRubyObject readNotAll(ThreadContext context, OpenFile myOpenFile, int length, RubyString str) {
         Ruby runtime = context.getRuntime();
-        
+
         try {
             myOpenFile.checkReadable(runtime);
             myOpenFile.setReadBuffered();
@@ -2282,7 +2278,7 @@
 
             // TODO: change this to check number read into buffer once that's working
     //        if (read == 0) {
-            
+
             if (newBuffer == null || newBuffer.length() == 0) {
                 if (myOpenFile.getMainStream() == null) {
                     return runtime.getNil();
@@ -2293,7 +2289,7 @@
                     if (str != null) {
                         str.setValue(ByteList.EMPTY_BYTELIST.dup());
                     }
-                
+
                     return runtime.getNil();
                 }
 
@@ -2339,23 +2335,23 @@
             throw runtime.newErrnoEBADFError();
         }
     }
-    
+
     protected IRubyObject readAll(IRubyObject buffer) throws BadDescriptorException, EOFException, IOException {
         Ruby runtime = getRuntime();
         // TODO: handle writing into original buffer better
-        
+
         RubyString str = null;
         if (buffer instanceof RubyString) {
             str = (RubyString)buffer;
         }
-        
+
         // TODO: ruby locks the string here
-        
+
         // READ_CHECK from MRI io.c
         if (openFile.getMainStream().readDataBuffered()) {
             openFile.checkClosed(runtime);
         }
-        
+
         ByteList newBuffer = openFile.getMainStream().readall();
 
         // TODO same zero-length checks as file above
@@ -2408,7 +2404,7 @@
 //
 //        return str;
     }
-    
+
     // TODO: There's a lot of complexity here due to error handling and
     // nonblocking IO; much of this goes away, but for now I'm just
     // having read call ChannelStream.fread directly.
@@ -2459,45 +2455,45 @@
 //            n--;
 //        }
 //        return len - n;
-//        
+//
 //    }
 
     /** Read a byte. On EOF throw EOFError.
-     * 
+     *
      */
     @JRubyMethod(name = "readchar")
     public IRubyObject readchar() {
         IRubyObject c = getc();
-        
+
         if (c.isNil()) throw getRuntime().newEOFError();
-        
+
         return c;
     }
-    
+
     @JRubyMethod
     public IRubyObject stat(ThreadContext context) {
         openFile.checkClosed(context.getRuntime());
         return context.getRuntime().newFileStat(getOpenFileChecked().getMainStream().getDescriptor().getFileDescriptor());
     }
 
-    /** 
+    /**
      * <p>Invoke a block for each byte.</p>
      */
     @JRubyMethod(name = "each_byte", frame = true)
     public IRubyObject each_byte(ThreadContext context, Block block) {
         Ruby runtime = context.getRuntime();
-        
+
     	try {
             OpenFile myOpenFile = getOpenFileChecked();
-            
+
             while (true) {
                 myOpenFile.checkReadable(runtime);
                 myOpenFile.setReadBuffered();
 
                 // TODO: READ_CHECK from MRI
-                
+
                 int c = myOpenFile.getMainStream().fgetc();
-                
+
                 if (c == -1) {
                     // TODO: check for error, clear it, and wait until readable before trying once more
 //                    if (ferror(f)) {
@@ -2508,7 +2504,7 @@
 //                    }
                     break;
                 }
-                
+
                 assert c < 256;
                 block.yield(context, getRuntime().newFixnum(c));
             }
@@ -2534,19 +2530,19 @@
         return block.isGiven() ? each_byte(context, block) : enumeratorize(context.getRuntime(), this, "each_byte");
     }
 
-    /** 
+    /**
      * <p>Invoke a block for each line.</p>
      */
     @JRubyMethod(name = {"each_line", "each"}, optional = 1, frame = true)
     public RubyIO each_line(ThreadContext context, IRubyObject[] args, Block block) {
         Ruby runtime = context.getRuntime();
         ByteList separator = getSeparatorForGets(runtime, args);
-        
-        for (IRubyObject line = getline(runtime, separator); !line.isNil(); 
+
+        for (IRubyObject line = getline(runtime, separator); !line.isNil();
         	line = getline(runtime, separator)) {
             block.yield(context, line);
         }
-        
+
         return this;
     }
 
@@ -2567,13 +2563,13 @@
         ByteList separator = getSeparatorForGets(runtime, separatorArgs);
         RubyArray result = runtime.newArray();
         IRubyObject line;
-        
+
         while (! (line = getline(runtime, separator)).isNil()) {
             result.append(line);
         }
         return result;
     }
-    
+
     @JRubyMethod(name = "to_io")
     public RubyIO to_io() {
     	return this;
@@ -2583,9 +2579,9 @@
     public String toString() {
         return "RubyIO(" + openFile.getMode() + ", " + openFile.getMainStream().getDescriptor().getFileno() + ")";
     }
-    
+
     /* class methods for IO */
-    
+
     /** rb_io_s_foreach
     *
     */
@@ -2595,11 +2591,11 @@
         int count = args.length;
         IRubyObject filename = args[0].convertToString();
         runtime.checkSafeString(filename);
-       
+
         ByteList separator = getSeparatorFromArgs(runtime, args, 1);
 
         RubyIO io = (RubyIO)RubyFile.open(context, runtime.getFile(), new IRubyObject[] { filename }, Block.NULL_BLOCK);
-        
+
         if (!io.isNil()) {
             try {
                 IRubyObject str = io.getline(runtime, separator);
@@ -2611,10 +2607,10 @@
                 io.close();
             }
         }
-       
+
         return runtime.getNil();
     }
-    
+
     @JRubyMethod(name = "foreach", required = 1, optional = 1, frame = true, meta = true, compat = CompatVersion.RUBY1_9)
     public static IRubyObject foreach19(final ThreadContext context, IRubyObject recv, IRubyObject[] args, final Block block) {
         return block.isGiven() ? foreach(context, recv, args, block) : enumeratorize(context.getRuntime(), recv, "foreach", args);
@@ -2623,26 +2619,26 @@
     private static RubyIO convertToIO(ThreadContext context, IRubyObject obj) {
         return (RubyIO)TypeConverter.convertToType(obj, context.getRuntime().getIO(), "to_io");
     }
-   
+
     private static boolean registerSelect(ThreadContext context, Selector selector, IRubyObject obj, RubyIO ioObj, int ops) throws IOException {
        Channel channel = ioObj.getChannel();
        if (channel == null || !(channel instanceof SelectableChannel)) {
            return false;
        }
-       
+
        ((SelectableChannel) channel).configureBlocking(false);
        int real_ops = ((SelectableChannel) channel).validOps() & ops;
        SelectionKey key = ((SelectableChannel) channel).keyFor(selector);
-       
+
        if (key == null) {
            ((SelectableChannel) channel).register(selector, real_ops, obj);
        } else {
            key.interestOps(key.interestOps()|real_ops);
        }
-       
+
        return true;
     }
-   
+
     @JRubyMethod(name = "select", required = 1, optional = 3, meta = true)
     public static IRubyObject select(ThreadContext context, IRubyObject recv, IRubyObject[] args) {
         return select_static(context, context.getRuntime(), args);
@@ -2715,21 +2711,21 @@
                    throw runtime.newArgumentError("negative timeout given");
                }
            }
-           
+
            if (pending.isEmpty() && unselectable_reads.isEmpty() && unselectable_writes.isEmpty()) {
                if (has_timeout) {
                    if (timeout==0) {
                        selector.selectNow();
                    } else {
-                       selector.select(timeout);                       
+                       selector.select(timeout);
                    }
                } else {
                    selector.select();
                }
            } else {
-               selector.selectNow();               
+               selector.selectNow();
            }
-           
+
            List r = new ArrayList();
            List w = new ArrayList();
            List e = new ArrayList();
@@ -2754,7 +2750,7 @@
            r.addAll(pending);
            r.addAll(unselectable_reads);
            w.addAll(unselectable_writes);
-           
+
            // make all sockets blocking as configured again
            for (Iterator i = selector.keys().iterator(); i.hasNext(); ) {
                SelectionKey key = (SelectionKey) i.next();
Index: src/org/jruby/RubySignal.java
===================================================================
--- src/org/jruby/RubySignal.java	(revision 8091)
+++ src/org/jruby/RubySignal.java	(working copy)
@@ -31,7 +31,6 @@
 import org.jruby.anno.JRubyModule;
 import org.jruby.javasupport.util.RuntimeHelpers;
 import org.jruby.runtime.Block;
-import org.jruby.runtime.CallType;
 import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.builtin.IRubyObject;
 
@@ -66,14 +65,14 @@
 
     @JRubyMethod(name = "trap", required = 1, optional = 1, frame = true, meta = true)
     public static IRubyObject trap(ThreadContext context, IRubyObject recv, IRubyObject[] args, Block block) {
-        Ruby runtime = recv.getRuntime();
+        Ruby runtime = context.getRuntime();
         runtime.getLoadService().require("jsignal");
         return RuntimeHelpers.invoke(context, runtime.getKernel(), "__jtrap", args, block);
     }
     
     @JRubyMethod(name = "list", meta = true)
     public static IRubyObject list(ThreadContext context, IRubyObject recv) {
-        Ruby runtime = recv.getRuntime();
+        Ruby runtime = context.getRuntime();
         RubyHash names = RubyHash.newHash(runtime);
         for (int i = 0; i < NAMES.length; i++) {
             names.op_aset(context, runtime.newString(NAMES[i]), runtime.newFixnum(i));
Index: tool/nailgun/src/java/org/jruby/util/NailMain.java
===================================================================
--- tool/nailgun/src/java/org/jruby/util/NailMain.java	(revision 8091)
+++ tool/nailgun/src/java/org/jruby/util/NailMain.java	(working copy)
@@ -5,6 +5,7 @@
 import org.jruby.RubyInstanceConfig;
 
 public class NailMain {
+
     public static void nailMain(NGContext context) {
         NailMain main = new NailMain();
         int status = main.run(context);
@@ -15,13 +16,13 @@
 
     public int run(NGContext context) {
         context.assertLoopbackClient();
-
         RubyInstanceConfig config = new RubyInstanceConfig();
-        // populate commandline with NG-provided stuff
+        config.setInput(context.in);
+        config.setOutput(context.out);
+        config.setError(context.err);
         config.processArguments(context.getArgs());
         config.setCurrentDirectory(context.getWorkingDirectory());
         config.setEnvironment(context.getEnv());
-
         Main main = new Main(config);
         return main.run();
     }