Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
   /*
    ***** BEGIN LICENSE BLOCK *****
    * Version: CPL 1.0/GPL 2.0/LGPL 2.1
    *
    * The contents of this file are subject to the Common Public
    * License Version 1.0 (the "License"); you may not use this file
    * except in compliance with the License. You may obtain a copy of
    * the License at http://www.eclipse.org/legal/cpl-v10.html
    *
   * Software distributed under the License is distributed on an "AS
   * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
   * implied. See the License for the specific language governing
   * rights and limitations under the License.
   *
   * Copyright (C) 2001 Chad Fowler <chadfowler@chadfowler.com>
   * Copyright (C) 2001 Alan Moore <alan_moore@gmx.net>
   * Copyright (C) 2001-2002 Benoit Cerrina <b.cerrina@wanadoo.fr>
   * Copyright (C) 2001-2004 Jan Arne Petersen <jpetersen@uni-bonn.de>
   * Copyright (C) 2002-2006 Thomas E Enebo <enebo@acm.org>
   * Copyright (C) 2002-2004 Anders Bengtsson <ndrsbngtssn@yahoo.se>
   * Copyright (C) 2004-2005 Charles O Nutter <headius@headius.com>
   * Copyright (C) 2004 Stefan Matthias Aust <sma@3plus4.de>
   * Copyright (C) 2005 Kiel Hodges <jruby-devel@selfsosoft.com>
   * Copyright (C) 2006 Evan Buswell <evan@heron.sytes.net>
   * Copyright (C) 2006 Ola Bini <ola@ologix.com>
   * Copyright (C) 2006 Michael Studman <codehaus@michaelstudman.com>
   * Copyright (C) 2006 Miguel Covarrubias <mlcovarrubias@gmail.com>
   * Copyright (C) 2007 Nick Sieger <nicksieger@gmail.com>
   * Copyright (C) 2008 Joseph LaFata <joe@quibb.org>
   * 
   * Alternatively, the contents of this file may be used under the terms of
   * either of the GNU General Public License Version 2 or later (the "GPL"),
   * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
   * in which case the provisions of the GPL or the LGPL are applicable instead
   * of those above. If you wish to allow use of your version of this file only
   * under the terms of either the GPL or the LGPL, and not to allow others to
   * use your version of this file under the terms of the CPL, indicate your
   * decision by deleting the provisions above and replace them with the notice
   * and other provisions required by the GPL or the LGPL. If you do not delete
   * the provisions above, a recipient may use your version of this file under
   * the terms of any one of the CPL, the GPL or the LGPL.
   ***** END LICENSE BLOCK *****/
  package org.jruby;
  
  
  import java.util.Arrays;
  import java.util.Map;
  
  import static org.jruby.CompatVersion.RUBY1_8;
  import static org.jruby.CompatVersion.RUBY1_9;
  import static org.jruby.RubyEnumerator.enumeratorize;
  import static org.jruby.anno.FrameField.BACKREF;
  import static org.jruby.anno.FrameField.BLOCK;
  import static org.jruby.anno.FrameField.LASTLINE;
  import static org.jruby.anno.FrameField.METHODNAME;
  import static org.jruby.runtime.Visibility.PRIVATE;
  import static org.jruby.runtime.Visibility.PROTECTED;
  import static org.jruby.runtime.Visibility.PUBLIC;

Note: For CVS history, see KernelModule.java.
  
  @JRubyModule(name="Kernel")
  public class RubyKernel {
      public final static Class<?> IRUBY_OBJECT = IRubyObject.class;
  
      public static abstract class MethodMissingMethod extends JavaMethodNBlock {
          public MethodMissingMethod(RubyModule implementationClass) {
              super(implementationClass..);
          }
  
         @Override
         public IRubyObject call(ThreadContext contextIRubyObject selfRubyModule clazzString nameIRubyObject[] argsBlock block) {
             return methodMissing(contextselfclazznameargsblock);
         }
 
         public abstract IRubyObject methodMissing(ThreadContext contextIRubyObject selfRubyModule clazzString nameIRubyObject[] argsBlock block);
 
     }
     public static RubyModule createKernelModule(Ruby runtime) {
         RubyModule module = runtime.defineModule("Kernel");
         runtime.setKernel(module);
 
         module.defineAnnotatedMethods(RubyKernel.class);
         
         module.setFlag(.false); //Kernel is the only Module that doesn't need an implementor
 
         runtime.setPrivateMethodMissing(new MethodMissingMethod(module) {
             @Override
             public IRubyObject methodMissing(ThreadContext contextIRubyObject selfRubyModule clazzString nameIRubyObject[] argsBlock block) {
                 return RubyKernel.methodMissing(contextselfname.argsblock);
             }
         });
 
         runtime.setProtectedMethodMissing(new MethodMissingMethod(module) {
             @Override
             public IRubyObject methodMissing(ThreadContext contextIRubyObject selfRubyModule clazzString nameIRubyObject[] argsBlock block) {
                 return RubyKernel.methodMissing(contextselfname.argsblock);
             }
         });
 
         runtime.setVariableMethodMissing(new MethodMissingMethod(module) {
             @Override
             public IRubyObject methodMissing(ThreadContext contextIRubyObject selfRubyModule clazzString nameIRubyObject[] argsBlock block) {
                 return RubyKernel.methodMissing(contextselfname.argsblock);
             }
         });
 
         runtime.setSuperMethodMissing(new MethodMissingMethod(module) {
             @Override
             public IRubyObject methodMissing(ThreadContext contextIRubyObject selfRubyModule clazzString nameIRubyObject[] argsBlock block) {
                 return RubyKernel.methodMissing(contextselfname.argsblock);
             }
         });
 
         runtime.setNormalMethodMissing(new MethodMissingMethod(module) {
             @Override
             public IRubyObject methodMissing(ThreadContext contextIRubyObject selfRubyModule clazzString nameIRubyObject[] argsBlock block) {
                 return RubyKernel.methodMissing(contextselfname.argsblock);
             }
         });
 
         recacheBuiltinMethods(runtime);
 
         return module;
     }

    
Cache built-in versions of several core methods, to improve performance by using identity comparison (==) rather than going ahead with dynamic dispatch.

Parameters:
runtime
 
     static void recacheBuiltinMethods(Ruby runtime) {
         RubyModule module = runtime.getKernel();
 
         runtime.setRespondToMethod(module.searchMethod("respond_to?"));
 
         if (!runtime.is1_9()) { // method_missing is in BasicObject in 1.9
             runtime.setDefaultMethodMissing(module.searchMethod("method_missing"));
         }
     }
 
     @JRubyMethod(module = true, visibility = )
     public static IRubyObject at_exit(ThreadContext contextIRubyObject recvBlock block) {
         return context.runtime.pushExitBlock(context.runtime.newProc(..block));
     }
 
     @JRubyMethod(name = "autoload?", required = 1, module = true, visibility = )
     public static IRubyObject autoload_p(ThreadContext contextfinal IRubyObject recvIRubyObject symbol) {
         Ruby runtime = context.runtime;
         final RubyModule module = getModuleForAutoload(runtimerecv);
         String name = symbol.asJavaString();
         
         String file = module.getAutoloadFile(name);
         return (file == null) ? runtime.getNil() : runtime.newString(file);
     }
 
     @JRubyMethod(required = 2, module = true, visibility = )
     public static IRubyObject autoload(final IRubyObject recvIRubyObject symbolIRubyObject file) {
         Ruby runtime = recv.getRuntime(); 
         String nonInternedName = symbol.asJavaString();
         
         if (!IdUtil.isValidConstantName(nonInternedName)) {
             throw runtime.newNameError("autoload must be constant name"nonInternedName);
         }
 
         final RubyString fileString;
         if (runtime.is1_9()) {
             fileString = RubyFile.get_path(runtime.getCurrentContext(), file);
         } else if (!(file instanceof RubyString)) {
             throw runtime.newTypeError(fileruntime.getString());
         } else {
             fileString = (RubyStringfile;
         }
         
         if (fileString.isEmpty()) throw runtime.newArgumentError("empty file name");
         
         final String baseName = symbol.asJavaString().intern(); // interned, OK for "fast" methods
         final RubyModule module = getModuleForAutoload(runtimerecv);
         
         IRubyObject existingValue = module.fetchConstant(baseName); 
         if (existingValue != null && existingValue != .return runtime.getNil();
 
         module.defineAutoload(baseNamenew IAutoloadMethod() {
             public String file() {
                 return fileString.asJavaString();
             }
 
             public void load(Ruby runtime) {
                 if (runtime.getLoadService().autoloadRequire(file())) {
                     // Do not finish autoloading by cyclic autoload 
                     module.finishAutoload(baseName);
                 }
             }
         });
         return runtime.getNil();
     }
 
     private static RubyModule getModuleForAutoload(Ruby runtimeIRubyObject recv) {
         RubyModule module = recv instanceof RubyModule ? (RubyModulerecv : recv.getMetaClass().getRealClass();
         if (module == runtime.getKernel()) {
             // special behavior if calling Kernel.autoload directly
             if (runtime.is1_9()) {
                 module = runtime.getObject().getSingletonClass();
             } else {
                 module = runtime.getObject();
             }
         }
         return module;
     }
 
     @JRubyMethod(rest = true, frame = true, visibility = , compat = )
     public static IRubyObject method_missing(ThreadContext contextIRubyObject recvIRubyObject[] argsBlock block) {
         Visibility lastVis = context.getLastVisibility();
         CallType lastCallType = context.getLastCallType();
 
         if (args.length == 0 || !(args[0] instanceof RubySymbol)) {
             throw context.runtime.newArgumentError("no id given");
         }
 
         return methodMissingDirect(contextrecv, (RubySymbol)args[0], lastVislastCallTypeargsblock);
     }
 
     protected static IRubyObject methodMissingDirect(ThreadContext contextIRubyObject recvRubySymbol symbolVisibility lastVisCallType lastCallTypeIRubyObject[] argsBlock block) {
         Ruby runtime = context.runtime;
         
         // create a lightweight thunk
         IRubyObject msg = new RubyNameError.RubyNameErrorMessage(runtime,
                                                                  recv,
                                                                  symbol,
                                                                  lastVis,
                                                                  lastCallType);
         final IRubyObject[]exArgs;
         final RubyClass exc;
         if (lastCallType != .) {
             exc = runtime.getNoMethodError();
             exArgs = new IRubyObject[]{msgsymbol, RubyArray.newArrayNoCopy(runtimeargs, 1)};
         } else {
             exc = runtime.getNameError();
             exArgs = new IRubyObject[]{msgsymbol};
         }
 
         throw new RaiseException((RubyException)exc.newInstance(contextexArgs.));
     }
 
     private static IRubyObject methodMissing(ThreadContext contextIRubyObject recvString nameVisibility lastVisCallType lastCallTypeIRubyObject[] argsBlock block) {
         Ruby runtime = context.runtime;
         RubySymbol symbol = runtime.newSymbol(name);
 
         // create a lightweight thunk
         IRubyObject msg = new RubyNameError.RubyNameErrorMessage(runtime,
                                                                  recv,
                                                                  symbol,
                                                                  lastVis,
                                                                  lastCallType);
         final IRubyObject[]exArgs;
         final RubyClass exc;
         if (lastCallType != .) {
             exc = runtime.getNoMethodError();
             exArgs = new IRubyObject[]{msgsymbol, RubyArray.newArrayNoCopy(runtimeargs)};
         } else {
             exc = runtime.getNameError();
             exArgs = new IRubyObject[]{msgsymbol};
         }
 
         throw new RaiseException((RubyException)exc.newInstance(contextexArgs.));
     }
     
 
     private static IRubyObject[] popenArgs(Ruby runtimeString pipedArgIRubyObject[] args) {
             IRubyObject command = runtime.newString(pipedArg.substring(1));
 
             if (args.length >= 2) return new IRubyObject[] { commandargs[1] };
 
             return new IRubyObject[] { command };
     }
     
     @JRubyMethod(required = 1, optional = 2, module = true, visibility = , compat = )
     public static IRubyObject open(ThreadContext contextIRubyObject recvIRubyObject[] argsBlock block) {
         String arg = args[0].convertToString().toString();
         Ruby runtime = context.runtime;
 
         // exec process, create IO with process
         if (arg.startsWith("|")) return RubyIO.popen(contextruntime.getIO(), popenArgs(runtimeargargs), block);
 
         return RubyFile.open(contextruntime.getFile(), argsblock);
     }
 
     @JRubyMethod(name = "open", required = 1, optional = 2, module = true, visibility = , compat = )
     public static IRubyObject open19(ThreadContext contextIRubyObject recvIRubyObject[] argsBlock block) {
         Ruby runtime = context.runtime;
         if (args[0].respondsTo("to_open")) {
             args[0] = args[0].callMethod(context"to_open");
             return RubyFile.open(contextruntime.getFile(), argsblock);
         } else {
             args[0] = RubyFile.get_path(contextargs[0]);
         }
 
         String arg = args[0].convertToString().toString();
 
         // exec process, create IO with process
         if (arg.startsWith("|")) return RubyIO.popen19(contextruntime.getIO(), popenArgs(runtimeargargs), block);
         
         return RubyFile.open(contextruntime.getFile(), argsblock);
     }
 
     @JRubyMethod(name = "getc", module = true, visibility = )
     public static IRubyObject getc(ThreadContext contextIRubyObject recv) {
         context.runtime.getWarnings().warn(."getc is obsolete; use STDIN.getc instead");
         IRubyObject defin = context.runtime.getGlobalVariables().get("$stdin");
         return defin.callMethod(context"getc");
     }
 
     @JRubyMethod(name = "gets", optional = 1, module = true, visibility = )
     public static IRubyObject gets(ThreadContext contextIRubyObject recvIRubyObject[] args) {
         return RubyArgsFile.gets(contextcontext.runtime.getArgsFile(), args);
     }
 
     @JRubyMethod(name = "abort", optional = 1, module = true, visibility = )
     public static IRubyObject abort(ThreadContext contextIRubyObject recvIRubyObject[] args) {
         Ruby runtime = context.runtime;
 
         if(args.length == 1) {
             runtime.getGlobalVariables().get("$stderr").callMethod(context,"puts",args[0].convertToString());
         }
         
         exit(runtimenew IRubyObject[] { runtime.getFalse() }, false);
         return runtime.getNil(); // not reached
     }
 
     @JRubyMethod(name = "Array", required = 1, module = true, visibility = )
     public static IRubyObject new_array(ThreadContext contextIRubyObject recvIRubyObject object) {
         return RuntimeHelpers.arrayValue(contextcontext.runtimeobject);
     }
 
     @JRubyMethod(name = "Complex", module = true, visibility = , compat = )
     public static IRubyObject new_complex(ThreadContext contextIRubyObject recv) {
         return RuntimeHelpers.invoke(contextcontext.runtime.getComplex(), "convert");
     }
     @JRubyMethod(name = "Complex", module = true, visibility = , compat = )
     public static IRubyObject new_complex(ThreadContext contextIRubyObject recvIRubyObject arg) {
         return RuntimeHelpers.invoke(contextcontext.runtime.getComplex(), "convert"arg);
     }
     @JRubyMethod(name = "Complex", module = true, visibility = , compat = )
     public static IRubyObject new_complex(ThreadContext contextIRubyObject recvIRubyObject arg0IRubyObject arg1) {
         return RuntimeHelpers.invoke(contextcontext.runtime.getComplex(), "convert"arg0arg1);
     }
     
     @JRubyMethod(name = "Rational", module = true, visibility = , compat = )
     public static IRubyObject new_rational(ThreadContext contextIRubyObject recv) {
         return RuntimeHelpers.invoke(contextcontext.runtime.getRational(), "convert");
     }
     @JRubyMethod(name = "Rational", module = true, visibility = , compat = )
     public static IRubyObject new_rational(ThreadContext contextIRubyObject recvIRubyObject arg) {
         return RuntimeHelpers.invoke(contextcontext.runtime.getRational(), "convert"arg);
     }
     @JRubyMethod(name = "Rational", module = true, visibility = , compat = )
     public static IRubyObject new_rational(ThreadContext contextIRubyObject recvIRubyObject arg0IRubyObject arg1) {
         return RuntimeHelpers.invoke(contextcontext.runtime.getRational(), "convert"arg0arg1);
     }
 
     @JRubyMethod(name = "Float", module = true, visibility = , compat = )
     public static RubyFloat new_float(IRubyObject recvIRubyObject object) {
         if(object instanceof RubyFixnum){
             return RubyFloat.newFloat(object.getRuntime(), ((RubyFixnum)object).getDoubleValue());
         }else if(object instanceof RubyFloat){
             return (RubyFloat)object;
         }else if(object instanceof RubyBignum){
             return RubyFloat.newFloat(object.getRuntime(), RubyBignum.big2dbl((RubyBignum)object));
         }else if(object instanceof RubyString){
             if(((RubyStringobject).getByteList().getRealSize() == 0){ // rb_cstr_to_dbl case
                 throw recv.getRuntime().newArgumentError("invalid value for Float(): " + object.inspect());
             }
             return RubyNumeric.str2fnum(recv.getRuntime(),(RubyString)object,true);
         }else if(object.isNil()){
             throw recv.getRuntime().newTypeError("can't convert nil into Float");
         } else {
             RubyFloat rFloat = (RubyFloat)TypeConverter.convertToType(objectrecv.getRuntime().getFloat(), "to_f");
             if (Double.isNaN(rFloat.getDoubleValue())) throw recv.getRuntime().newArgumentError("invalid value for Float()");
             return rFloat;
         }
     }
 
     @JRubyMethod(name = "Float", module = true, visibility = , compat = )
     public static RubyFloat new_float19(IRubyObject recvIRubyObject object) {
         Ruby runtime = recv.getRuntime();
         if(object instanceof RubyFixnum){
             return RubyFloat.newFloat(runtime, ((RubyFixnum)object).getDoubleValue());
         } else if (object instanceof RubyFloat) {
             return (RubyFloat)object;
         } else if(object instanceof RubyBignum){
             return RubyFloat.newFloat(runtime, RubyBignum.big2dbl((RubyBignum)object));
         } else if(object instanceof RubyString){
             if(((RubyStringobject).getByteList().getRealSize() == 0){ // rb_cstr_to_dbl case
                 throw runtime.newArgumentError("invalid value for Float(): " + object.inspect());
             }
             RubyString arg = (RubyString)object;
             if (arg.toString().startsWith("0x")) {
                 return ConvertBytes.byteListToInum19(runtimearg.getByteList(), 16, true).toFloat();
             }
             return RubyNumeric.str2fnum19(runtimearg,true);
         } else if(object.isNil()){
             throw runtime.newTypeError("can't convert nil into Float");
         } else {
             return (RubyFloat)TypeConverter.convertToType19(objectruntime.getFloat(), "to_f");
         }
     }
     
     @JRubyMethod(name = "Hash", required = 1, module = true, visibility = , compat = )
     public static IRubyObject new_hash(ThreadContext contextIRubyObject recvIRubyObject arg) {
         IRubyObject tmp;
         Ruby runtime = recv.getRuntime();
         if (arg.isNil()) return RubyHash.newHash(runtime);
         tmp = TypeConverter.checkHashType(runtimearg);
         if (tmp.isNil()) {
             if (arg instanceof RubyArray && ((RubyArrayarg).isEmpty()) {
                 return RubyHash.newHash(runtime);
             }
             throw runtime.newTypeError("can't convert " + arg.getMetaClass() + " into Hash");
         }
         return tmp;
     } 
 
     @JRubyMethod(name = "Integer", required = 1, module = true, visibility = , compat = )
     public static IRubyObject new_integer(ThreadContext contextIRubyObject recvIRubyObject object) {
         if (object instanceof RubyFloat) {
             double val = ((RubyFloat)object).getDoubleValue();
             if (val >= (double. || val < (double.) {
                 return RubyNumeric.dbl2num(context.runtime,((RubyFloat)object).getDoubleValue());
             }
         } else if (object instanceof RubyFixnum || object instanceof RubyBignum) {
             return object;
         } else if (object instanceof RubyString) {
             return RubyNumeric.str2inum(context.runtime,(RubyString)object,0,true);
         }
 
         IRubyObject tmp = TypeConverter.convertToType(objectcontext.runtime.getInteger(), "to_int"false);
         if (tmp.isNil()) return object.convertToInteger("to_i");
         return tmp;
     }
 
     @JRubyMethod(name = "Integer", module = true, visibility = , compat = )
     public static IRubyObject new_integer19(ThreadContext contextIRubyObject recvIRubyObject object) {
         if (object instanceof RubyFloat) {
             double val = ((RubyFloat)object).getDoubleValue(); 
             if (val > (double. && val < (double.) {
                 return RubyNumeric.dbl2num(context.runtime,((RubyFloat)object).getDoubleValue());
             }
         } else if (object instanceof RubyFixnum || object instanceof RubyBignum) {
             return object;
         } else if (object instanceof RubyString) {
             return RubyNumeric.str2inum(context.runtime,(RubyString)object,0,true);
         } else if(object instanceof RubyNil) {
             throw context.runtime.newTypeError("can't convert nil into Integer");
         }
 
         IRubyObject tmp = TypeConverter.convertToType(objectcontext.runtime.getInteger(), "to_int"false);
         if (tmp.isNil()) return object.convertToInteger("to_i");
         return tmp;
     }
 
     @JRubyMethod(name = "Integer", module = true, visibility = , compat = )
     public static IRubyObject new_integer19(ThreadContext contextIRubyObject recvIRubyObject objectIRubyObject base) {
         int bs = RubyNumeric.num2int(base);
         if(object instanceof RubyString) {
             return RubyNumeric.str2inum(context.runtime,(RubyString)object,bs,true);
         } else {
             IRubyObject tmp = object.checkStringType();
             if(!tmp.isNil()) {
                 return RubyNumeric.str2inum(context.runtime,(RubyString)tmp,bs,true);
             }
         }
         throw context.runtime.newArgumentError("base specified for non string value");
     }
 
     @JRubyMethod(name = "String", required = 1, module = true, visibility = , compat = )
     public static IRubyObject new_string(ThreadContext contextIRubyObject recvIRubyObject object) {
         return TypeConverter.convertToType(objectcontext.runtime.getString(), "to_s");
     }
 
     @JRubyMethod(name = "String", required = 1, module = true, visibility = , compat = )
     public static IRubyObject new_string19(ThreadContext contextIRubyObject recvIRubyObject object) {
         return TypeConverter.convertToType19(objectcontext.runtime.getString(), "to_s");
     }
 
     @JRubyMethod(name = "p", rest = true, module = true, visibility = )
     public static IRubyObject p(ThreadContext contextIRubyObject recvIRubyObject[] args) {
         Ruby runtime = context.runtime;
         IRubyObject defout = runtime.getGlobalVariables().get("$>");
 
         for (int i = 0; i < args.lengthi++) {
             if (args[i] != null) {
                 defout.callMethod(context"write", RubyObject.inspect(contextargs[i]));
                 defout.callMethod(context"write"runtime.newString("\n"));
             }
         }
 
         IRubyObject result = runtime.getNil();
         if (runtime.is1_9()) {
             if (args.length == 1) {
                 result = args[0];
             } else if (args.length > 1) {
                 result = runtime.newArray(args);
             }
         }
 
         if (defout instanceof RubyFile) {
             ((RubyFile)defout).flush();
         }
 
         return result;
     }
 
     @JRubyMethod(name = "public_method",required = 1, module = true, compat = )
     public static IRubyObject public_method(ThreadContext contextIRubyObject recvIRubyObject symbol) {
         return recv.getMetaClass().newMethod(recvsymbol.asJavaString(), truetruefalse);
     }

    
rb_f_putc
 
     @JRubyMethod(name = "putc", required = 1, module = true, visibility = )
     public static IRubyObject putc(ThreadContext contextIRubyObject recvIRubyObject ch) {
         IRubyObject defout = context.runtime.getGlobalVariables().get("$>");
         
         return RubyIO.putc(contextdefoutch);
     }
 
     @JRubyMethod(name = "puts", rest = true, module = true, visibility = )
     public static IRubyObject puts(ThreadContext contextIRubyObject recvIRubyObject[] args) {
         IRubyObject defout = context.runtime.getGlobalVariables().get("$>");
 
         return RubyIO.puts(contextdefoutargs);
     }
 
     @JRubyMethod(name = "print", rest = true, module = true, visibility = )
     public static IRubyObject print(ThreadContext contextIRubyObject recvIRubyObject[] args) {
         IRubyObject defout = context.runtime.getGlobalVariables().get("$>");
 
         return RubyIO.print(contextdefoutargs);
     }
 
     @JRubyMethod(name = "printf", rest = true, module = true, visibility = )
     public static IRubyObject printf(ThreadContext contextIRubyObject recvIRubyObject[] args) {
         if (args.length != 0) {
             IRubyObject defout = context.runtime.getGlobalVariables().get("$>");
 
             if (!(args[0] instanceof RubyString)) {
                 defout = args[0];
                 args = ArgsUtil.popArray(args);
             }
 
             defout.callMethod(context"write", RubyKernel.sprintf(contextrecvargs));
         }
 
         return context.runtime.getNil();
     }
 
     @JRubyMethod(name = "readline", optional = 1, module = true, visibility = )
     public static IRubyObject readline(ThreadContext contextIRubyObject recvIRubyObject[] args) {
         IRubyObject line = gets(contextrecvargs);
 
         if (line.isNil()) {
             throw context.runtime.newEOFError();
         }
 
         return line;
     }
 
     @JRubyMethod(name = "readlines", optional = 1, module = true, visibility = )
     public static IRubyObject readlines(ThreadContext contextIRubyObject recvIRubyObject[] args) {
         return RubyArgsFile.readlines(contextcontext.runtime.getArgsFile(), args);
     }
 
     @JRubyMethod(name = "respond_to_missing?", module = true, compat = )
     public static IRubyObject respond_to_missing_p(ThreadContext contextIRubyObject recvIRubyObject symbol) {
         return context.runtime.getFalse();
     }
 
     @JRubyMethod(name = "respond_to_missing?", module = true, compat = )
     public static IRubyObject respond_to_missing_p(ThreadContext contextIRubyObject recvIRubyObject symbolIRubyObject isPrivate) {
         return context.runtime.getFalse();
     }

    
Returns value of $_.

Returns:
value of $_ as String.
Throws:
TypeError if $_ is not a String or nil.
 
     private static RubyString getLastlineString(ThreadContext contextRuby runtime) {
         IRubyObject line = context.getCurrentScope().getLastLine(runtime);
 
         if (line.isNil()) {
             throw runtime.newTypeError("$_ value need to be String (nil given).");
         } else if (!(line instanceof RubyString)) {
             throw runtime.newTypeError("$_ value need to be String (" + line.getMetaClass().getName() + " given).");
         } else {
             return (RubyStringline;
         }
     }
 
     @JRubyMethod(name = "sub!", module = true, visibility = , reads = , compat = )
     public static IRubyObject sub_bang(ThreadContext contextIRubyObject recvIRubyObject arg0Block block) {
         return getLastlineString(contextcontext.runtime).sub_bang(contextarg0block);
     }
 
     @JRubyMethod(name = "sub!", module = true, visibility = , reads = , compat = )
     public static IRubyObject sub_bang(ThreadContext contextIRubyObject recvIRubyObject arg0IRubyObject arg1Block block) {
         return getLastlineString(contextcontext.runtime).sub_bang(contextarg0arg1block);
     }
 
     @JRubyMethod(name = "sub", module = true, visibility = , reads = , writes = , compat = )
     public static IRubyObject sub(ThreadContext contextIRubyObject recvIRubyObject arg0Block block) {
         RubyString str = (RubyStringgetLastlineString(contextcontext.runtime).dup();
 
         if (!str.sub_bang(contextarg0block).isNil()) {
             context.getCurrentScope().setLastLine(str);
         }
 
         return str;
     }
 
     @JRubyMethod(name = "sub", module = true, visibility = , reads = , writes = , compat = )
     public static IRubyObject sub(ThreadContext contextIRubyObject recvIRubyObject arg0IRubyObject arg1Block block) {
         RubyString str = (RubyStringgetLastlineString(contextcontext.runtime).dup();
 
         if (!str.sub_bang(contextarg0arg1block).isNil()) {
             context.getCurrentScope().setLastLine(str);
         }
 
         return str;
     }
 
     @JRubyMethod(name = "gsub!", module = true, visibility = , reads = , writes = , compat = )
     public static IRubyObject gsub_bang(ThreadContext contextIRubyObject recvIRubyObject arg0Block block) {
         return getLastlineString(contextcontext.runtime).gsub_bang(contextarg0block);
     }
 
     @JRubyMethod(name = "gsub!", module = true, visibility = , reads = , writes = , compat = )
     public static IRubyObject gsub_bang(ThreadContext contextIRubyObject recvIRubyObject arg0IRubyObject arg1Block block) {
         return getLastlineString(contextcontext.runtime).gsub_bang(contextarg0arg1block);
     }
 
     @JRubyMethod(module = true, visibility = , reads = , writes = , compat = )
     public static IRubyObject gsub(ThreadContext contextIRubyObject recvIRubyObject arg0Block block) {
         RubyString str = (RubyStringgetLastlineString(contextcontext.runtime).dup();
 
         if (!str.gsub_bang(contextarg0block).isNil()) {
             context.getCurrentScope().setLastLine(str);
         }
 
         return str;
     }
 
     @JRubyMethod(module = true, visibility = , reads = , writes = , compat = )
     public static IRubyObject gsub(ThreadContext contextIRubyObject recvIRubyObject arg0IRubyObject arg1Block block) {
         RubyString str = (RubyStringgetLastlineString(contextcontext.runtime).dup();
 
         if (!str.gsub_bang(contextarg0arg1block).isNil()) {
             context.getCurrentScope().setLastLine(str);
         }
 
         return str;
     }
 
     @JRubyMethod(name = "chop!", module = true, visibility = , reads = , writes = , compat = )
     public static IRubyObject chop_bang(ThreadContext contextIRubyObject recvBlock block) {
         return getLastlineString(contextcontext.runtime).chop_bang(context);
     }
 
     @JRubyMethod(module = true, visibility = , reads = , writes = , compat = )
     public static IRubyObject chop(ThreadContext contextIRubyObject recvBlock block) {
         RubyString str = getLastlineString(contextcontext.runtime);
 
         if (str.getByteList().getRealSize() > 0) {
             str = (RubyStringstr.dup();
             str.chop_bang(context);
             context.getCurrentScope().setLastLine(str);
         }
 
         return str;
     }
 
     @JRubyMethod(name = "chomp!", module = true, visibility = , reads = , writes = , compat = )
     public static IRubyObject chomp_bang(ThreadContext contextIRubyObject recv) {
         return getLastlineString(contextcontext.runtime).chomp_bang(context);
     }
 
     @JRubyMethod(name = "chomp!", module = true, visibility = , reads = , writes = , compat = )
     public static IRubyObject chomp_bang(ThreadContext contextIRubyObject recvIRubyObject arg0) {
         return getLastlineString(contextcontext.runtime).chomp_bang(contextarg0);
     }
 
     @JRubyMethod(module = true, visibility = , reads = , writes = , compat = )
     public static IRubyObject chomp(ThreadContext contextIRubyObject recv) {
         RubyString str = getLastlineString(contextcontext.runtime);
         RubyString dup = (RubyStringstr.dup();
 
         if (dup.chomp_bang(context).isNil()) {
             return str;
         } 
 
         context.getCurrentScope().setLastLine(dup);
         return dup;
     }
 
     @JRubyMethod(module = true, visibility = , reads = , writes = , compat = )
     public static IRubyObject chomp(ThreadContext contextIRubyObject recvIRubyObject arg0) {
         RubyString str = getLastlineString(contextcontext.runtime);
         RubyString dup = (RubyStringstr.dup();
 
         if (dup.chomp_bang(contextarg0).isNil()) {
             return str;
         } 
 
         context.getCurrentScope().setLastLine(dup);
         return dup;
     }
 
     @JRubyMethod(module = true, visibility = , reads = , writes = {}, compat = )
     public static IRubyObject split(ThreadContext contextIRubyObject recv) {
         return getLastlineString(contextcontext.runtime).split(context);
     }
 
     @JRubyMethod(module = true, visibility = , reads = , writes = {}, compat = )
     public static IRubyObject split(ThreadContext contextIRubyObject recvIRubyObject arg0) {
         return getLastlineString(contextcontext.runtime).split(contextarg0);
     }
 
     @JRubyMethod(module = true, visibility = , reads = , writes = {}, compat = )
     public static IRubyObject split(ThreadContext contextIRubyObject recvIRubyObject arg0IRubyObject arg1) {
         return getLastlineString(contextcontext.runtime).split(contextarg0arg1);
     }
 
     @JRubyMethod(module = true, visibility = , reads = {}, writes = {}, compat = )
     public static IRubyObject scan(ThreadContext contextIRubyObject recvIRubyObject patternBlock block) {
         return getLastlineString(contextcontext.runtime).scan(contextpatternblock);
     }
 
     @JRubyMethod(required = 1, optional = 3, module = true, visibility = )
     public static IRubyObject select(ThreadContext contextIRubyObject recvIRubyObject[] args) {
         return RubyIO.select_static(contextcontext.runtimeargs);
     }
 
     @JRubyMethod(optional = 1, module = true, visibility = )
     public static IRubyObject sleep(ThreadContext contextIRubyObject recvIRubyObject[] args) {
         long milliseconds;
 
         if (args.length == 0) {
             // Zero sleeps forever
             milliseconds = 0;
         } else {
             if (!(args[0] instanceof RubyNumeric)) {
                 throw context.runtime.newTypeError("can't convert " + args[0].getMetaClass().getName() + "into time interval");
             }
             milliseconds = (long) (args[0].convertToFloat().getDoubleValue() * 1000);
             if (milliseconds < 0) {
                 throw context.runtime.newArgumentError("time interval must be positive");
             } else if (milliseconds == 0) {
                 // Explicit zero in MRI returns immediately
                 return context.runtime.newFixnum(0);
             }
         }
         long startTime = System.currentTimeMillis();
         
         RubyThread rubyThread = context.getThread();
 
         // Spurious wakeup-loop
         do {
             long loopStartTime = System.currentTimeMillis();
             try {
                 // We break if we know this sleep was explicitly woken up/interrupted
                 if (!rubyThread.sleep(milliseconds)) break;
             } catch (InterruptedException iExcptn) {
             }
             milliseconds -= (System.currentTimeMillis() - loopStartTime);
         } while (milliseconds > 0);
 
         return context.runtime.newFixnum(Math.round((System.currentTimeMillis() - startTime) / 1000.0));
     }
 
     // FIXME: Add at_exit and finalizers to exit, then make exit_bang not call those.
     @JRubyMethod(name = "exit", optional = 1, module = true, visibility = )
     public static IRubyObject exit(IRubyObject recvIRubyObject[] args) {
         exit(recv.getRuntime(), argsfalse);
         return recv.getRuntime().getNil(); // not reached
     }
 
     @JRubyMethod(name = "exit!", optional = 1, module = true, visibility = )
     public static IRubyObject exit_bang(IRubyObject recvIRubyObject[] args) {
         exit(recv.getRuntime(), argstrue);
         return recv.getRuntime().getNil(); // not reached
     }
 
     private static void exit(Ruby runtimeIRubyObject[] argsboolean hard) {
         int status = hard ? 1 : 0;
 
         if (args.length > 0) {
             RubyObject argument = (RubyObjectargs[0];
             if (argument instanceof RubyBoolean) {
                 status = argument.isFalse() ? 1 : 0;
             } else {
                 status = RubyNumeric.fix2int(argument);
             }
         }
 
         if (hard) {
             if (runtime.getInstanceConfig().isHardExit()) {
                 System.exit(status);
             } else {
                 throw new MainExitException(statustrue);
             }
         } else {
             throw runtime.newSystemExit(status);
         }
     }


    
Returns an Array with the names of all global variables.
 
     @JRubyMethod(name = "global_variables", module = true, visibility = )
     public static RubyArray global_variables(ThreadContext contextIRubyObject recv) {
         Ruby runtime = context.runtime;
         RubyArray globalVariables = runtime.newArray();
 
         for (String globalVariableName : runtime.getGlobalVariables().getNames()) {
             globalVariables.append(runtime.newString(globalVariableName));
         }
 
         return globalVariables;
     }
 
     // In 1.9, return symbols
     @JRubyMethod(name = "global_variables", module = true, visibility = , compat = )
     public static RubyArray global_variables19(ThreadContext contextIRubyObject recv) {
         Ruby runtime = context.runtime;
         RubyArray globalVariables = runtime.newArray();
 
         for (String globalVariableName : runtime.getGlobalVariables().getNames()) {
             globalVariables.append(runtime.newSymbol(globalVariableName));
         }
 
         return globalVariables;
     }

    
Returns an Array with the names of all local variables.
 
     @JRubyMethod(name = "local_variables", module = true, visibility = )
     public static RubyArray local_variables(ThreadContext contextIRubyObject recv) {
         final Ruby runtime = context.runtime;
         RubyArray localVariables = runtime.newArray();