Helpers.java

  1. package org.jruby.runtime;

  3. import java.io.UnsupportedEncodingException;
  4. import java.lang.reflect.Array;
  5. import java.nio.channels.ClosedChannelException;
  6. import java.nio.charset.Charset;

  8. import jnr.constants.platform.Errno;
  9. import org.jruby.*;
  10. import org.jruby.ast.ArgsNode;
  11. import org.jruby.ast.ArgumentNode;
  12. import org.jruby.ast.DAsgnNode;
  13. import org.jruby.ast.LocalAsgnNode;
  14. import org.jruby.ast.MultipleAsgn19Node;
  15. import org.jruby.ast.Node;
  16. import org.jruby.ast.OptArgNode;
  17. import org.jruby.ast.UnnamedRestArgNode;
  18. import org.jruby.ast.util.ArgsUtil;
  19. import org.jruby.common.IRubyWarnings.ID;
  20. import org.jruby.evaluator.ASTInterpreter;
  21. import org.jruby.exceptions.JumpException;
  22. import org.jruby.exceptions.RaiseException;
  23. import org.jruby.exceptions.Unrescuable;
  24. import org.jruby.internal.runtime.methods.*;
  25. import org.jruby.ir.IRMethod;
  26. import org.jruby.ir.IRScopeType;
  27. import org.jruby.ir.operands.UndefinedValue;
  28. import org.jruby.javasupport.JavaClass;
  29. import org.jruby.javasupport.JavaUtil;
  30. import org.jruby.lexer.yacc.ISourcePosition;
  31. import org.jruby.lexer.yacc.SimpleSourcePosition;
  32. import org.jruby.parser.StaticScope;
  33. import org.jruby.platform.Platform;
  34. import org.jruby.runtime.backtrace.BacktraceData;
  35. import org.jruby.runtime.builtin.IRubyObject;
  36. import org.jruby.runtime.invokedynamic.MethodNames;
  37. import org.jruby.util.ByteList;
  38. import org.jruby.util.DefinedMessage;
  39. import org.jruby.util.TypeConverter;

  41. import java.util.ArrayList;
  42. import java.util.Arrays;
  43. import java.util.HashMap;
  44. import java.util.List;
  45. import java.util.Map;
  46. import java.util.StringTokenizer;
  47. import org.jcodings.Encoding;
  48. import org.jcodings.specific.ASCIIEncoding;
  49. import org.jcodings.specific.USASCIIEncoding;
  50. import org.jcodings.specific.UTF8Encoding;
  51. import org.jcodings.unicode.UnicodeEncoding;

  53. import static org.jruby.runtime.invokedynamic.MethodNames.EQL;
  54. import static org.jruby.runtime.invokedynamic.MethodNames.OP_EQUAL;
  55. import static org.jruby.util.CodegenUtils.sig;

  57. import org.jruby.util.JavaNameMangler;

  59. /**
  60.  * Helper methods which are called by the compiler.  Note: These will show no consumers, but
  61.  * generated code does call these so don't remove them thinking they are dead code. 
  62.  *
  63.  */
  64. public class Helpers {
  65.     public static CallSite selectAttrAsgnCallSite(IRubyObject receiver, IRubyObject self, CallSite normalSite, CallSite variableSite) {
  66.         if (receiver == self) return variableSite;
  67.         return normalSite;
  68.     }
  69.     public static IRubyObject doAttrAsgn(IRubyObject receiver, CallSite callSite, IRubyObject value, ThreadContext context, IRubyObject caller) {
  70.         callSite.call(context, caller, receiver, value);
  71.         return value;
  72.     }
  73.     public static IRubyObject doAttrAsgn(IRubyObject receiver, CallSite callSite, IRubyObject arg0, IRubyObject value, ThreadContext context, IRubyObject caller) {
  74.         callSite.call(context, caller, receiver, arg0, value);
  75.         return value;
  76.     }
  77.     public static IRubyObject doAttrAsgn(IRubyObject receiver, CallSite callSite, IRubyObject arg0, IRubyObject arg1, IRubyObject value, ThreadContext context, IRubyObject caller) {
  78.         callSite.call(context, caller, receiver, arg0, arg1, value);
  79.         return value;
  80.     }
  81.     public static IRubyObject doAttrAsgn(IRubyObject receiver, CallSite callSite, IRubyObject arg0, IRubyObject arg1, IRubyObject arg2, IRubyObject value, ThreadContext context, IRubyObject caller) {
  82.         callSite.call(context, caller, receiver, arg0, arg1, arg2, value);
  83.         return value;
  84.     }
  85.     public static IRubyObject doAttrAsgn(IRubyObject receiver, CallSite callSite, IRubyObject[] args, ThreadContext context, IRubyObject caller) {
  86.         callSite.call(context, caller, receiver, args);
  87.         return args[args.length - 1];
  88.     }
  89.     public static IRubyObject doAttrAsgn(IRubyObject receiver, CallSite callSite, IRubyObject[] args, IRubyObject value, ThreadContext context, IRubyObject caller) {
  90.         IRubyObject[] newArgs = new IRubyObject[args.length + 1];
  91.         System.arraycopy(args, 0, newArgs, 0, args.length);
  92.         newArgs[args.length] = value;
  93.         callSite.call(context, caller, receiver, newArgs);
  94.         return value;
  95.     }

  97.     public static boolean invokeEqqForCaseWhen(CallSite callSite, ThreadContext context, IRubyObject caller, IRubyObject arg, IRubyObject[] receivers) {
  98.         for (int i = 0; i < receivers.length; i++) {
  99.             IRubyObject receiver = receivers[i];
  100.             if (invokeEqqForCaseWhen(callSite, context, caller, arg, receiver)) return true;
  101.         }
  102.         return false;
  103.     }

  105.     public static boolean invokeEqqForCaseWhen(CallSite callSite, ThreadContext context, IRubyObject caller, IRubyObject arg, IRubyObject receiver) {
  106.         IRubyObject result = callSite.call(context, caller, receiver, arg);
  107.         if (result.isTrue()) return true;
  108.         return false;
  109.     }

  111.     public static boolean invokeEqqForCaseWhen(CallSite callSite, ThreadContext context, IRubyObject caller, IRubyObject arg, IRubyObject receiver0, IRubyObject receiver1) {
  112.         IRubyObject result = callSite.call(context, caller, receiver0, arg);
  113.         if (result.isTrue()) return true;
  114.         return invokeEqqForCaseWhen(callSite, context, caller, arg, receiver1);
  115.     }

  117.     public static boolean invokeEqqForCaseWhen(CallSite callSite, ThreadContext context, IRubyObject caller, IRubyObject arg, IRubyObject receiver0, IRubyObject receiver1, IRubyObject receiver2) {
  118.         IRubyObject result = callSite.call(context, caller, receiver0, arg);
  119.         if (result.isTrue()) return true;
  120.         return invokeEqqForCaseWhen(callSite, context, caller, arg, receiver1, receiver2);
  121.     }

  123.     public static boolean invokeEqqForCaselessWhen(IRubyObject[] receivers) {
  124.         for (int i = 0; i < receivers.length; i++) {
  125.             if (receivers[i].isTrue()) return true;
  126.         }
  127.         return false;
  128.     }

  130.     public static boolean invokeEqqForCaselessWhen(IRubyObject receiver) {
  131.         return receiver.isTrue();
  132.     }

  134.     public static boolean invokeEqqForCaselessWhen(IRubyObject receiver0, IRubyObject receiver1) {
  135.         return receiver0.isTrue() || receiver1.isTrue();
  136.     }

  138.     public static boolean invokeEqqForCaselessWhen(IRubyObject receiver0, IRubyObject receiver1, IRubyObject receiver2) {
  139.         return receiver0.isTrue() || receiver1.isTrue() || receiver2.isTrue();
  140.     }
  141.     
  142.     public static CompiledBlockCallback createBlockCallback(Object scriptObject, String closureMethod, String file, int line) {
  143.         Class scriptClass = scriptObject.getClass();
  144.         ClassLoader scriptClassLoader = scriptClass.getClassLoader();
  145.         MethodFactory factory = MethodFactory.createFactory(scriptClassLoader);
  146.         
  147.         return factory.getBlockCallback(closureMethod, file, line, scriptObject);
  148.     }

  150.     public static CompiledBlockCallback19 createBlockCallback19(Object scriptObject, String closureMethod, String file, int line) {
  151.         Class scriptClass = scriptObject.getClass();
  152.         ClassLoader scriptClassLoader = scriptClass.getClassLoader();
  153.         MethodFactory factory = MethodFactory.createFactory(scriptClassLoader);

  155.         return factory.getBlockCallback19(closureMethod, file, line, scriptObject);
  156.     }

  158.     public static byte[] createBlockCallbackOffline(String classPath, String closureMethod, String file, int line) {
  159.         MethodFactory factory = MethodFactory.createFactory(Helpers.class.getClassLoader());

  161.         return factory.getBlockCallbackOffline(closureMethod, file, line, classPath);
  162.     }

  164.     public static byte[] createBlockCallback19Offline(String classPath, String closureMethod, String file, int line) {
  165.         MethodFactory factory = MethodFactory.createFactory(Helpers.class.getClassLoader());

  167.         return factory.getBlockCallback19Offline(closureMethod, file, line, classPath);
  168.     }
  169.     
  170.     public static String[] parseBlockDescriptor(String descriptor) {
  171.         String[] mangled = descriptor.split(":");
  172.         mangled[0] = JavaNameMangler.demangleMethodName(mangled[0]);
  173.         mangled[4] = JavaNameMangler.demangleMethodName(mangled[4]);
  174.         return mangled;
  175.     }

  177.     public static BlockBody createCompiledBlockBody(ThreadContext context, Object scriptObject, StaticScope scope, String descriptor) {
  178.         String[] firstSplit = parseBlockDescriptor(descriptor);
  179.         return createCompiledBlockBody(context, scriptObject, firstSplit[0], Integer.parseInt(firstSplit[1]), scope, Boolean.valueOf(firstSplit[2]), Integer.parseInt(firstSplit[3]), firstSplit[4], Integer.parseInt(firstSplit[5]), Boolean.valueOf(firstSplit[6]));
  180.     }
  181.     
  182.     public static BlockBody createCompiledBlockBody(ThreadContext context, Object scriptObject, String closureMethod, int arity,
  183.             StaticScope staticScope, boolean hasMultipleArgsHead, int argsNodeType, String file, int line, boolean light) {
  184.         staticScope.determineModule();
  185.         
  186.         if (light) {
  187.             return CompiledBlockLight.newCompiledBlockLight(
  188.                     Arity.createArity(arity), staticScope,
  189.                     createBlockCallback(scriptObject, closureMethod, file, line),
  190.                     hasMultipleArgsHead, argsNodeType);
  191.         } else {
  192.             return CompiledBlock.newCompiledBlock(
  193.                     Arity.createArity(arity), staticScope,
  194.                     createBlockCallback(scriptObject, closureMethod, file, line),
  195.                     hasMultipleArgsHead, argsNodeType);
  196.         }
  197.     }

  199.     public static BlockBody createCompiledBlockBody19(ThreadContext context, Object scriptObject, StaticScope scope, String descriptor) {
  200.         String[] firstSplit = parseBlockDescriptor(descriptor);
  201.         return createCompiledBlockBody19(context, scriptObject, firstSplit[0], Integer.parseInt(firstSplit[1]), scope, Boolean.valueOf(firstSplit[2]), Integer.parseInt(firstSplit[3]), firstSplit[4], Integer.parseInt(firstSplit[5]), Boolean.valueOf(firstSplit[6]), firstSplit[7]);
  202.     }

  204.     public static BlockBody createCompiledBlockBody19(ThreadContext context, Object scriptObject, String closureMethod, int arity,
  205.             StaticScope staticScope, boolean hasMultipleArgsHead, int argsNodeType, String file, int line, boolean light, String parameterList) {
  206.         staticScope.determineModule();

  208.         if (light) {
  209.             return CompiledBlockLight19.newCompiledBlockLight(
  210.                     Arity.createArity(arity), staticScope,
  211.                     createBlockCallback19(scriptObject, closureMethod, file, line),
  212.                     hasMultipleArgsHead, argsNodeType, parameterList.split(";"));
  213.         } else {
  214.             return CompiledBlock19.newCompiledBlock(
  215.                     Arity.createArity(arity), staticScope,
  216.                     createBlockCallback19(scriptObject, closureMethod, file, line),
  217.                     hasMultipleArgsHead, argsNodeType, parameterList.split(";"));
  218.         }
  219.     }
  220.     
  221.     public static Block createBlock(ThreadContext context, IRubyObject self, BlockBody body) {
  222.         return CompiledBlock.newCompiledClosure(
  223.                 context,
  224.                 self,
  225.                 body);
  226.     }

  228.     public static Block createBlock19(ThreadContext context, IRubyObject self, BlockBody body) {
  229.         return CompiledBlock19.newCompiledClosure(
  230.                 context,
  231.                 self,
  232.                 body);
  233.     }
  234.     
  235.     public static IRubyObject runBeginBlock(ThreadContext context, IRubyObject self, String scopeString, CompiledBlockCallback callback) {
  236.         StaticScope staticScope = decodeScope(context, context.getCurrentStaticScope(), scopeString);
  237.         
  238.         context.preScopedBody(DynamicScope.newDynamicScope(staticScope, context.getCurrentScope()));
  239.         
  240.         Block block = CompiledBlock.newCompiledClosure(context, self, Arity.createArity(0), staticScope, callback, false, BlockBody.ZERO_ARGS);
  241.         
  242.         try {
  243.             block.yield(context, null);
  244.         } finally {
  245.             context.postScopedBody();
  246.         }

  248.         return context.runtime.getNil();
  249.     }

  251.     public static Block createSharedScopeBlock(ThreadContext context, IRubyObject self, int arity,
  252.             CompiledBlockCallback callback, boolean hasMultipleArgsHead, int argsNodeType) {

  254.         return CompiledSharedScopeBlock.newCompiledSharedScopeClosure(context, self, Arity.createArity(arity),
  255.                 context.getCurrentScope(), callback, hasMultipleArgsHead, argsNodeType);
  256.     }

  258.     public static IRubyObject def(ThreadContext context, IRubyObject self, Object scriptObject, String rubyName, String javaName, StaticScope scope,
  259.                                   int arity, String filename, int line, CallConfiguration callConfig, String parameterDesc) {
  260.         // TODO: Need to have access to AST for recompilation. See #1395
  261.         final MethodNodes methodNodes = MethodNodes.lookup(javaName);
  262.         return def(context, self, scriptObject, rubyName, javaName, scope, arity, filename, line, callConfig, parameterDesc, methodNodes);
  263.     }

  265.     public static IRubyObject def(ThreadContext context, IRubyObject self, Object scriptObject, String rubyName, String javaName, StaticScope scope,
  266.                                   int arity, String filename, int line, CallConfiguration callConfig, String parameterDesc, MethodNodes methodNodes) {
  267.         Class compiledClass = scriptObject.getClass();
  268.         Ruby runtime = context.runtime;

  270.         Visibility currVisibility = context.getCurrentVisibility();
  271.         Visibility newVisibility = performNormalMethodChecksAndDetermineVisibility(runtime, null, rubyName, currVisibility);

  273.         MethodFactory factory = MethodFactory.createFactory(compiledClass.getClassLoader());
  274.         DynamicMethod method = constructNormalMethod(
  275.                 factory, javaName,
  276.                 rubyName, null, new SimpleSourcePosition(filename, line), arity, scope, newVisibility, scriptObject,
  277.                 callConfig,
  278.                 parameterDesc,
  279.                 methodNodes);

  281.         // TODO(CS): The MethodNodes don't pass through to the method object correctly - bypass.

  283.         if (method instanceof CompiledMethod) {
  284.             ((CompiledMethod) method).unsafeSetMethodNodes(methodNodes);
  285.         }

  287.         return addInstanceMethod(null, rubyName, method, currVisibility, context, runtime);
  288.     }

  290.     public static IRubyObject defs(ThreadContext context, IRubyObject self, IRubyObject receiver, Object scriptObject, String rubyName, String javaName, StaticScope scope,
  291.                                    int arity, String filename, int line, CallConfiguration callConfig, String parameterDesc) {
  292.         // TODO: Need to have access to AST for recompilation. See #1395
  293.         final MethodNodes methodNodes = MethodNodes.lookup(javaName);
  294.         return defs(context, self, receiver, scriptObject, rubyName, javaName, scope, arity, filename, line, callConfig, parameterDesc, methodNodes);
  295.     }

  297.     public static IRubyObject defs(ThreadContext context, IRubyObject self, IRubyObject receiver, Object scriptObject, String rubyName, String javaName, StaticScope scope,
  298.             int arity, String filename, int line, CallConfiguration callConfig, String parameterDesc, MethodNodes methodNodes) {
  299.         Class compiledClass = scriptObject.getClass();
  300.         Ruby runtime = context.runtime;

  302.         RubyClass rubyClass = performSingletonMethodChecks(runtime, receiver, rubyName);
  303.         
  304.         MethodFactory factory = MethodFactory.createFactory(compiledClass.getClassLoader());
  305.         DynamicMethod method = constructSingletonMethod(
  306.                 factory, rubyName, javaName, rubyClass,
  307.                 new SimpleSourcePosition(filename, line), arity, scope,
  308.                 scriptObject, callConfig, parameterDesc, methodNodes);

  310.         // TODO(CS): The MethodNodes don't pass through to the method object correctly - bypass.

  312.         if (method instanceof CompiledMethod) {
  313.             ((CompiledMethod) method).unsafeSetMethodNodes(methodNodes);
  314.         }
  315.         
  316.         rubyClass.addMethod(rubyName, method);
  317.         
  318.         callSingletonMethodHook(receiver,context, runtime.fastNewSymbol(rubyName));
  319.         
  320.         return runtime.newSymbol(rubyName);
  321.     }

  323.     public static byte[] defOffline(String rubyName, String javaName, String classPath, String invokerName, Arity arity, StaticScope scope, CallConfiguration callConfig, String filename, int line, MethodNodes methodNodes) {
  324.         MethodFactory factory = MethodFactory.createFactory(Helpers.class.getClassLoader());
  325.         byte[] methodBytes = factory.getCompiledMethodOffline(rubyName, javaName, classPath, invokerName, arity, scope, callConfig, filename, line, methodNodes);

  327.         return methodBytes;
  328.     }
  329.     
  330.     public static RubyClass getSingletonClass(Ruby runtime, IRubyObject receiver) {
  331.         if (receiver instanceof RubyFixnum || receiver instanceof RubySymbol) {
  332.             throw runtime.newTypeError("can't define singleton");
  333.         } else {
  334.             return receiver.getSingletonClass();
  335.         }
  336.     }

  338.     // TODO: Only used by interface implementation; eliminate it
  339.     public static IRubyObject invokeMethodMissing(IRubyObject receiver, String name, IRubyObject[] args) {
  340.         ThreadContext context = receiver.getRuntime().getCurrentContext();

  342.         // store call information so method_missing impl can use it
  343.         context.setLastCallStatusAndVisibility(CallType.FUNCTIONAL, Visibility.PUBLIC);

  345.         if (name.equals("method_missing")) {
  346.             return RubyKernel.method_missing(context, receiver, args, Block.NULL_BLOCK);
  347.         }

  349.         IRubyObject[] newArgs = prepareMethodMissingArgs(args, context, name);

  351.         return invoke(context, receiver, "method_missing", newArgs, Block.NULL_BLOCK);
  352.     }

  354.     public static IRubyObject callMethodMissing(ThreadContext context, IRubyObject receiver, Visibility visibility, String name, CallType callType, IRubyObject[] args, Block block) {
  355.         return selectMethodMissing(context, receiver, visibility, name, callType).call(context, receiver, receiver.getMetaClass(), name, args, block);
  356.     }

  358.     public static IRubyObject callMethodMissing(ThreadContext context, IRubyObject receiver, Visibility visibility, String name, CallType callType, IRubyObject arg0, Block block) {
  359.         return selectMethodMissing(context, receiver, visibility, name, callType).call(context, receiver, receiver.getMetaClass(), name, arg0, block);
  360.     }

  362.     public static IRubyObject callMethodMissing(ThreadContext context, IRubyObject receiver, Visibility visibility, String name, CallType callType, IRubyObject arg0, IRubyObject arg1, Block block) {
  363.         return selectMethodMissing(context, receiver, visibility, name, callType).call(context, receiver, receiver.getMetaClass(), name, arg0, arg1, block);
  364.     }

  366.     public static IRubyObject callMethodMissing(ThreadContext context, IRubyObject receiver, Visibility visibility, String name, CallType callType, IRubyObject arg0, IRubyObject arg1, IRubyObject arg2, Block block) {
  367.         return selectMethodMissing(context, receiver, visibility, name, callType).call(context, receiver, receiver.getMetaClass(), name, arg0, arg1, arg2, block);
  368.     }

  370.     public static IRubyObject callMethodMissing(ThreadContext context, IRubyObject receiver, Visibility visibility, String name, CallType callType, Block block) {
  371.         return selectMethodMissing(context, receiver, visibility, name, callType).call(context, receiver, receiver.getMetaClass(), name, block);
  372.     }

  374.     public static DynamicMethod selectMethodMissing(ThreadContext context, IRubyObject receiver, Visibility visibility, String name, CallType callType) {
  375.         Ruby runtime = context.runtime;

  377.         if (name.equals("method_missing")) {
  378.             return selectInternalMM(runtime, visibility, callType);
  379.         }

  381.         DynamicMethod methodMissing = receiver.getMetaClass().searchMethod("method_missing");
  382.         if (methodMissing.isUndefined() || methodMissing.equals(runtime.getDefaultMethodMissing())) {
  383.             return selectInternalMM(runtime, visibility, callType);
  384.         }
  385.         return new MethodMissingMethod(methodMissing, callType);
  386.     }

  388.     public static DynamicMethod selectMethodMissing(ThreadContext context, RubyClass selfClass, Visibility visibility, String name, CallType callType) {
  389.         Ruby runtime = context.runtime;

  391.         if (name.equals("method_missing")) {
  392.             return selectInternalMM(runtime, visibility, callType);
  393.         }

  395.         DynamicMethod methodMissing = selfClass.searchMethod("method_missing");
  396.         if (methodMissing.isUndefined() || methodMissing.equals(runtime.getDefaultMethodMissing())) {
  397.             return selectInternalMM(runtime, visibility, callType);
  398.         }
  399.         return new MethodMissingMethod(methodMissing, callType);
  400.     }

  402.     public static DynamicMethod selectMethodMissing(RubyClass selfClass, Visibility visibility, String name, CallType callType) {
  403.         Ruby runtime = selfClass.getClassRuntime();

  405.         if (name.equals("method_missing")) {
  406.             return selectInternalMM(runtime, visibility, callType);
  407.         }

  409.         DynamicMethod methodMissing = selfClass.searchMethod("method_missing");
  410.         if (methodMissing.isUndefined() || methodMissing.equals(runtime.getDefaultMethodMissing())) {
  411.             return selectInternalMM(runtime, visibility, callType);
  412.         }
  413.         return new MethodMissingMethod(methodMissing, callType);
  414.     }

  416.     public static final Map<String, String> map(String... keyValues) {
  417.         HashMap<String, String> map = new HashMap<String, String>(keyValues.length / 2);
  418.         for (int i = 0; i < keyValues.length;) {
  419.             map.put(keyValues[i++], keyValues[i++]);
  420.         }
  421.         return map;
  422.     }

  424.     /**
  425.      * Should be called on jumps out of blocks.  Inspects the jump, returning or rethrowing as appropriate
  426.      */
  427.     public static IRubyObject handleBlockJump(ThreadContext context, JumpException.FlowControlException jump, Block.Type type) {
  428.         // 'next' and Lambda 'return' are local returns from the block, ending the call or yield
  429.         if (jump instanceof JumpException.NextJump
  430.                 || (jump instanceof JumpException.ReturnJump && type == Block.Type.LAMBDA)) {
  431.             return jump.getValue() == null ? context.runtime.getNil() : (IRubyObject)jump.getValue();
  432.         }

  434.         // other jumps propagate up
  435.         throw jump;
  436.     }

  438.     public static boolean additionOverflowed(long original, long other, long result) {
  439.         return (~(original ^ other) & (original ^ result) & RubyFixnum.SIGN_BIT) != 0;
  440.     }

  442.     public static boolean subtractionOverflowed(long original, long other, long result) {
  443.         return (~(original ^ ~other) & (original ^ result) & RubyFixnum.SIGN_BIT) != 0;
  444.     }

  446.     public static Errno errnoFromException(Throwable t) {
  447.         if (t instanceof ClosedChannelException) {
  448.             return Errno.EBADF;
  449.         }

  451.         // TODO: this is kinda gross
  452.         if(t.getMessage() != null) {
  453.             String errorMessage = t.getMessage();

  455.             // All errors to sysread should be SystemCallErrors, but on a closed stream
  456.             // Ruby returns an IOError.  Java throws same exception for all errors so
  457.             // we resort to this hack...

  459.             if ("Bad file descriptor".equals(errorMessage)) {
  460.                 return Errno.EBADF;
  461.             } else if ("File not open".equals(errorMessage)) {
  462.                 return null;
  463.             } else if ("An established connection was aborted by the software in your host machine".equals(errorMessage)) {
  464.                 return Errno.ECONNABORTED;
  465.             } else if (t.getMessage().equals("Broken pipe")) {
  466.                 return Errno.EPIPE;
  467.             } else if ("Connection reset by peer".equals(errorMessage) ||
  468.                        "An existing connection was forcibly closed by the remote host".equals(errorMessage) ||
  469.                     (Platform.IS_WINDOWS && errorMessage.contains("connection was aborted"))) {
  470.                 return Errno.ECONNRESET;
  471.             } else if (errorMessage.equals("No space left on device")) {
  472.                 return Errno.ENOSPC;
  473.             }
  474.         }
  475.         return null;
  476.     }

  478.     public static RubyModule getNthScopeModule(StaticScope scope, int depth) {
  479.         int n = depth;
  480.         while (n > 0) {
  481.             scope = scope.getEnclosingScope();
  482.             if (scope.getScopeType() != null) {
  483.                 n--;
  484.             }
  485.         }
  486.         return scope.getModule();
  487.     }

  489.     public static RubyArray viewArgsArray(ThreadContext context, RubyArray rubyArray, int preArgsCount, int postArgsCount) {
  490.         int n = rubyArray.getLength();
  491.         if ((preArgsCount >= n) || (preArgsCount + postArgsCount >= n)) {
  492.             return RubyArray.newEmptyArray(context.runtime);
  493.         } else {
  494.             return (RubyArray)rubyArray.subseqLight(preArgsCount, n - preArgsCount - postArgsCount);
  495.         }
  496.     }

  498.     public static Class[] getStaticMethodParams(Class target, int args) {
  499.         switch (args) {
  500.         case 0:
  501.             return new Class[] {target, ThreadContext.class, IRubyObject.class, Block.class};
  502.         case 1:
  503.             return new Class[] {target, ThreadContext.class, IRubyObject.class, IRubyObject.class, Block.class};
  504.         case 2:
  505.             return new Class[] {target, ThreadContext.class, IRubyObject.class, IRubyObject.class, IRubyObject.class, Block.class};
  506.         case 3:
  507.             return new Class[] {target, ThreadContext.class, IRubyObject.class, IRubyObject.class, IRubyObject.class, IRubyObject.class, Block.class};
  508.         case 4:
  509.             return new Class[] {target, ThreadContext.class, IRubyObject.class, IRubyObject[].class, Block.class};
  510.         default:
  511.             throw new RuntimeException("unsupported arity: " + args);
  512.         }
  513.     }

  515.     public static String getStaticMethodSignature(String classname, int args) {
  516.         switch (args) {
  517.         case 0:
  518.             return sig(IRubyObject.class, "L" + classname + ";", ThreadContext.class, IRubyObject.class, Block.class);
  519.         case 1:
  520.             return sig(IRubyObject.class, "L" + classname + ";", ThreadContext.class, IRubyObject.class, IRubyObject.class, Block.class);
  521.         case 2:
  522.             return sig(IRubyObject.class, "L" + classname + ";", ThreadContext.class, IRubyObject.class, IRubyObject.class, IRubyObject.class, Block.class);
  523.         case 3:
  524.             return sig(IRubyObject.class, "L" + classname + ";", ThreadContext.class, IRubyObject.class, IRubyObject.class, IRubyObject.class, IRubyObject.class, Block.class);
  525.         case 4:
  526.             return sig(IRubyObject.class, "L" + classname + ";", ThreadContext.class, IRubyObject.class, IRubyObject[].class, Block.class);
  527.         default:
  528.             throw new RuntimeException("unsupported arity: " + args);
  529.         }
  530.     }

  532.     private static class MethodMissingMethod extends DynamicMethod {
  533.         private final DynamicMethod delegate;
  534.         private final CallType lastCallStatus;

  536.         public MethodMissingMethod(DynamicMethod delegate, CallType lastCallStatus) {
  537.             this.delegate = delegate;
  538.             this.lastCallStatus = lastCallStatus;
  539.         }

  541.         @Override
  542.         public IRubyObject call(ThreadContext context, IRubyObject self, RubyModule clazz, String name, IRubyObject[] args, Block block) {
  543.             context.setLastCallStatus(lastCallStatus);
  544.             return this.delegate.call(context, self, clazz, "method_missing", prepareMethodMissingArgs(args, context, name), block);
  545.         }

  547.         @Override
  548.         public DynamicMethod dup() {
  549.             return this;
  550.         }
  551.     }

  553.     private static DynamicMethod selectInternalMM(Ruby runtime, Visibility visibility, CallType callType) {
  554.         if (visibility == Visibility.PRIVATE) {
  555.             return runtime.getPrivateMethodMissing();
  556.         } else if (visibility == Visibility.PROTECTED) {
  557.             return runtime.getProtectedMethodMissing();
  558.         } else if (callType == CallType.VARIABLE) {
  559.             return runtime.getVariableMethodMissing();
  560.         } else if (callType == CallType.SUPER) {
  561.             return runtime.getSuperMethodMissing();
  562.         } else {
  563.             return runtime.getNormalMethodMissing();
  564.         }
  565.     }

  567.     private static IRubyObject[] prepareMethodMissingArgs(IRubyObject[] args, ThreadContext context, String name) {
  568.         IRubyObject[] newArgs = new IRubyObject[args.length + 1];
  569.         System.arraycopy(args, 0, newArgs, 1, args.length);
  570.         newArgs[0] = context.runtime.newSymbol(name);

  572.         return newArgs;
  573.     }
  574.     
  575.     public static IRubyObject invoke(ThreadContext context, IRubyObject self, String name, Block block) {
  576.         return self.getMetaClass().finvoke(context, self, name, block);
  577.     }
  578.     public static IRubyObject invoke(ThreadContext context, IRubyObject self, String name, IRubyObject arg0, Block block) {
  579.         return self.getMetaClass().finvoke(context, self, name, arg0, block);
  580.     }
  581.     public static IRubyObject invoke(ThreadContext context, IRubyObject self, String name, IRubyObject arg0, IRubyObject arg1, Block block) {
  582.         return self.getMetaClass().finvoke(context, self, name, arg0, arg1, block);
  583.     }
  584.     public static IRubyObject invoke(ThreadContext context, IRubyObject self, String name, IRubyObject arg0, IRubyObject arg1, IRubyObject arg2, Block block) {
  585.         return self.getMetaClass().finvoke(context, self, name, arg0, arg1, arg2, block);
  586.     }
  587.     public static IRubyObject invoke(ThreadContext context, IRubyObject self, String name, IRubyObject[] args, Block block) {
  588.         return self.getMetaClass().finvoke(context, self, name, args, block);
  589.     }
  590.     
  591.     public static IRubyObject invoke(ThreadContext context, IRubyObject self, String name) {
  592.         return self.getMetaClass().finvoke(context, self, name);
  593.     }
  594.     public static IRubyObject invoke(ThreadContext context, IRubyObject self, String name, IRubyObject arg0) {
  595.         return self.getMetaClass().finvoke(context, self, name, arg0);
  596.     }
  597.     public static IRubyObject invoke(ThreadContext context, IRubyObject self, String name, IRubyObject arg0, IRubyObject arg1) {
  598.         return self.getMetaClass().finvoke(context, self, name, arg0, arg1);
  599.     }
  600.     public static IRubyObject invoke(ThreadContext context, IRubyObject self, String name, IRubyObject arg0, IRubyObject arg1, IRubyObject arg2) {
  601.         return self.getMetaClass().finvoke(context, self, name, arg0, arg1, arg2);
  602.     }
  603.     public static IRubyObject invoke(ThreadContext context, IRubyObject self, String name, IRubyObject... args) {
  604.         return self.getMetaClass().finvoke(context, self, name, args);
  605.     }
  606.     
  607.     public static IRubyObject invoke(ThreadContext context, IRubyObject self, String name, CallType callType) {
  608.         return Helpers.invoke(context, self, name, IRubyObject.NULL_ARRAY, callType, Block.NULL_BLOCK);
  609.     }
  610.     public static IRubyObject invoke(ThreadContext context, IRubyObject self, String name, IRubyObject[] args, CallType callType, Block block) {
  611.         return self.getMetaClass().invoke(context, self, name, args, callType, block);
  612.     }
  613.     
  614.     public static IRubyObject invoke(ThreadContext context, IRubyObject self, String name, IRubyObject arg, CallType callType, Block block) {
  615.         return self.getMetaClass().invoke(context, self, name, arg, callType, block);
  616.     }
  617.     
  618.     public static IRubyObject invokeAs(ThreadContext context, RubyClass asClass, IRubyObject self, String name, IRubyObject[] args, Block block) {
  619.         return asClass.finvoke(context, self, name, args, block);
  620.     }
  621.     
  622.     public static IRubyObject invokeAs(ThreadContext context, RubyClass asClass, IRubyObject self, String name, Block block) {
  623.         return asClass.finvoke(context, self, name, block);
  624.     }
  625.     
  626.     public static IRubyObject invokeAs(ThreadContext context, RubyClass asClass, IRubyObject self, String name, IRubyObject arg0, Block block) {
  627.         return asClass.finvoke(context, self, name, arg0, block);
  628.     }
  629.     
  630.     public static IRubyObject invokeAs(ThreadContext context, RubyClass asClass, IRubyObject self, String name, IRubyObject arg0, IRubyObject arg1, Block block) {
  631.         return asClass.finvoke(context, self, name, arg0, arg1, block);
  632.     }
  633.     
  634.     public static IRubyObject invokeAs(ThreadContext context, RubyClass asClass, IRubyObject self, String name, IRubyObject arg0, IRubyObject arg1, IRubyObject arg2, Block block) {
  635.         return asClass.finvoke(context, self, name, arg0, arg1, arg2, block);
  636.     }

  638.     public static IRubyObject invokeChecked(ThreadContext context, IRubyObject self, String name) {
  639.         return self.getMetaClass().finvokeChecked(context, self, name);
  640.     }

  642.     /**
  643.      * The protocol for super method invocation is a bit complicated
  644.      * in Ruby. In real terms it involves first finding the real
  645.      * implementation class (the super class), getting the name of the
  646.      * method to call from the frame, and then invoke that on the
  647.      * super class with the current self as the actual object
  648.      * invoking.
  649.      */
  650.     public static IRubyObject invokeSuper(ThreadContext context, IRubyObject self, IRubyObject[] args, Block block) {
  651.         return invokeSuper(context, self, context.getFrameKlazz(), context.getFrameName(), args, block);
  652.     }

  654.     public static IRubyObject invokeSuper(ThreadContext context, IRubyObject self, RubyModule klass, String name, IRubyObject[] args, Block block) {
  655.         checkSuperDisabledOrOutOfMethod(context, klass, name);

  657.         RubyClass superClass = findImplementerIfNecessary(self.getMetaClass(), klass).getSuperClass();
  658.         DynamicMethod method = superClass != null ? superClass.searchMethod(name) : UndefinedMethod.INSTANCE;

  660.         if (method.isUndefined()) {
  661.             return callMethodMissing(context, self, method.getVisibility(), name, CallType.SUPER, args, block);
  662.         }
  663.         return method.call(context, self, superClass, name, args, block);
  664.     }
  665.     
  666.     public static IRubyObject invokeSuper(ThreadContext context, IRubyObject self, Block block) {
  667.         checkSuperDisabledOrOutOfMethod(context);
  668.         RubyModule klazz = context.getFrameKlazz();
  669.         String name = context.getFrameName();

  671.         RubyClass superClass = findImplementerIfNecessary(self.getMetaClass(), klazz).getSuperClass();
  672.         DynamicMethod method = superClass != null ? superClass.searchMethod(name) : UndefinedMethod.INSTANCE;

  674.         if (method.isUndefined()) {
  675.             return callMethodMissing(context, self, method.getVisibility(), name, CallType.SUPER, block);
  676.         }
  677.         return method.call(context, self, superClass, name, block);
  678.     }
  679.     
  680.     public static IRubyObject invokeSuper(ThreadContext context, IRubyObject self, IRubyObject arg0, Block block) {
  681.         checkSuperDisabledOrOutOfMethod(context);
  682.         RubyModule klazz = context.getFrameKlazz();
  683.         String name = context.getFrameName();

  685.         RubyClass superClass = findImplementerIfNecessary(self.getMetaClass(), klazz).getSuperClass();
  686.         DynamicMethod method = superClass != null ? superClass.searchMethod(name) : UndefinedMethod.INSTANCE;

  688.         if (method.isUndefined()) {
  689.             return callMethodMissing(context, self, method.getVisibility(), name, CallType.SUPER, arg0, block);
  690.         }
  691.         return method.call(context, self, superClass, name, arg0, block);
  692.     }
  693.     
  694.     public static IRubyObject invokeSuper(ThreadContext context, IRubyObject self, IRubyObject arg0, IRubyObject arg1, Block block) {
  695.         checkSuperDisabledOrOutOfMethod(context);
  696.         RubyModule klazz = context.getFrameKlazz();
  697.         String name = context.getFrameName();

  699.         RubyClass superClass = findImplementerIfNecessary(self.getMetaClass(), klazz).getSuperClass();
  700.         DynamicMethod method = superClass != null ? superClass.searchMethod(name) : UndefinedMethod.INSTANCE;

  702.         if (method.isUndefined()) {
  703.             return callMethodMissing(context, self, method.getVisibility(), name, CallType.SUPER, arg0, arg1, block);
  704.         }
  705.         return method.call(context, self, superClass, name, arg0, arg1, block);
  706.     }
  707.     
  708.     public static IRubyObject invokeSuper(ThreadContext context, IRubyObject self, IRubyObject arg0, IRubyObject arg1, IRubyObject arg2, Block block) {
  709.         checkSuperDisabledOrOutOfMethod(context);
  710.         RubyModule klazz = context.getFrameKlazz();
  711.         String name = context.getFrameName();

  713.         RubyClass superClass = findImplementerIfNecessary(self.getMetaClass(), klazz).getSuperClass();
  714.         DynamicMethod method = superClass != null ? superClass.searchMethod(name) : UndefinedMethod.INSTANCE;

  716.         if (method.isUndefined()) {
  717.             return callMethodMissing(context, self, method.getVisibility(), name, CallType.SUPER, arg0, arg1, arg2, block);
  718.         }
  719.         return method.call(context, self, superClass, name, arg0, arg1, arg2, block);
  720.     }

  722.     public static RubyArray ensureRubyArray(IRubyObject value) {
  723.         return ensureRubyArray(value.getRuntime(), value);
  724.     }

  726.     public static RubyArray ensureRubyArray(Ruby runtime, IRubyObject value) {
  727.         return value instanceof RubyArray ? (RubyArray)value : RubyArray.newArray(runtime, value);
  728.     }

  730.     public static RubyArray ensureMultipleAssignableRubyArray(IRubyObject value, Ruby runtime, boolean masgnHasHead) {
  731.         if (!(value instanceof RubyArray)) {
  732.             value = ArgsUtil.convertToRubyArray19(runtime, value, masgnHasHead);
  733.         }
  734.         return (RubyArray) value;
  735.     }
  736.     
  737.     public static IRubyObject fetchClassVariable(Ruby runtime, StaticScope scope,
  738.             IRubyObject self, String name) {
  739.         RubyModule rubyClass = ASTInterpreter.getClassVariableBase(runtime, scope);
  740.    
  741.         if (rubyClass == null) rubyClass = self.getMetaClass();

  743.         return rubyClass.getClassVar(name);
  744.     }
  745.     
  746.     public static IRubyObject getConstant(ThreadContext context, String internedName) {
  747.         Ruby runtime = context.runtime;

  749.         return context.getCurrentScope().getStaticScope().getConstantWithConstMissing(internedName);
  750.     }

  752.     public static IRubyObject nullToNil(IRubyObject value, ThreadContext context) {
  753.         return value != null ? value : context.nil;
  754.     }
  755.     
  756.     public static IRubyObject nullToNil(IRubyObject value, Ruby runtime) {
  757.         return value != null ? value : runtime.getNil();
  758.     }
  759.     
  760.     public static IRubyObject nullToNil(IRubyObject value, IRubyObject nil) {
  761.         return value != null ? value : nil;
  762.     }
  763.     
  764.     public static RubyClass prepareSuperClass(Ruby runtime, IRubyObject rubyClass) {
  765.         RubyClass.checkInheritable(rubyClass); // use the same logic as in EvaluationState
  766.         return (RubyClass)rubyClass;
  767.     }
  768.     
  769.     public static RubyModule prepareClassNamespace(ThreadContext context, StaticScope scope, IRubyObject rubyModule) {
  770.         if (rubyModule == null || rubyModule.isNil()) {
  771.             rubyModule = scope.getModule();

  773.             if (rubyModule == null) {
  774.                 throw context.runtime.newTypeError("no outer class/module");
  775.             }
  776.         }

  778.         if (rubyModule instanceof RubyModule) {
  779.             return (RubyModule)rubyModule;
  780.         } else {
  781.             throw context.runtime.newTypeError(rubyModule + " is not a class/module");
  782.         }
  783.     }
  784.     
  785.     public static IRubyObject setClassVariable(Ruby runtime, StaticScope scope,
  786.             IRubyObject self, String name, IRubyObject value) {
  787.         RubyModule rubyClass = ASTInterpreter.getClassVariableBase(runtime, scope);
  788.    
  789.         if (rubyClass == null) rubyClass = self.getMetaClass();

  791.         rubyClass.setClassVar(name, value);
  792.    
  793.         return value;
  794.     }
  795.     
  796.     public static IRubyObject declareClassVariable(Ruby runtime, StaticScope scope, IRubyObject self, String name, IRubyObject value) {
  797.         // FIXME: This isn't quite right; it shouldn't evaluate the value if it's going to throw the error
  798.         RubyModule rubyClass = ASTInterpreter.getClassVariableBase(runtime, scope);
  799.    
  800.         if (rubyClass == null) throw runtime.newTypeError("no class/module to define class variable");
  801.         
  802.         rubyClass.setClassVar(name, value);
  803.    
  804.         return value;
  805.     }
  806.     
  807.     public static void handleArgumentSizes(ThreadContext context, Ruby runtime, int given, int required, int opt, int rest) {
  808.         if (opt == 0) {
  809.             if (rest < 0) {
  810.                 // no opt, no rest, exact match
  811.                 if (given != required) {
  812.                     throw runtime.newArgumentError("wrong number of arguments (" + given + " for " + required + ")");
  813.                 }
  814.             } else {
  815.                 // only rest, must be at least required
  816.                 if (given < required) {
  817.                     throw runtime.newArgumentError("wrong number of arguments (" + given + " for " + required + ")");
  818.                 }
  819.             }
  820.         } else {
  821.             if (rest < 0) {
  822.                 // opt but no rest, must be at least required and no more than required + opt
  823.                 if (given < required) {
  824.                     throw runtime.newArgumentError("wrong number of arguments (" + given + " for " + required + ")");
  825.                 } else if (given > (required + opt)) {
  826.                     throw runtime.newArgumentError("wrong number of arguments (" + given + " for " + (required + opt) + ")");
  827.                 }
  828.             } else {
  829.                 // opt and rest, must be at least required
  830.                 if (given < required) {
  831.                     throw runtime.newArgumentError("wrong number of arguments (" + given + " for " + required + ")");
  832.                 }
  833.             }
  834.         }
  835.     }
  836.     
  837.     public static String getLocalJumpTypeOrRethrow(RaiseException re) {
  838.         RubyException exception = re.getException();
  839.         Ruby runtime = exception.getRuntime();
  840.         if (runtime.getLocalJumpError().isInstance(exception)) {
  841.             RubyLocalJumpError jumpError = (RubyLocalJumpError)re.getException();

  843.             IRubyObject reason = jumpError.reason();

  845.             return reason.asJavaString();
  846.         }

  848.         throw re;
  849.     }
  850.     
  851.     public static IRubyObject unwrapLocalJumpErrorValue(RaiseException re) {
  852.         return ((RubyLocalJumpError)re.getException()).exit_value();
  853.     }
  854.     
  855.     public static IRubyObject processBlockArgument(Ruby runtime, Block block) {
  856.         if (!block.isGiven()) {
  857.             return runtime.getNil();
  858.         }
  859.         
  860.         return processGivenBlock(block, runtime);
  861.     }

  863.     private static IRubyObject processGivenBlock(Block block, Ruby runtime) {
  864.         RubyProc blockArg = block.getProcObject();

  866.         if (blockArg == null) {
  867.             blockArg = runtime.newBlockPassProc(Block.Type.PROC, block);
  868.             blockArg.getBlock().type = Block.Type.PROC;
  869.         }

  871.         return blockArg;
  872.     }
  873.     
  874.     public static Block getBlockFromBlockPassBody(Ruby runtime, IRubyObject proc, Block currentBlock) {
  875.         // No block from a nil proc
  876.         if (proc.isNil()) return Block.NULL_BLOCK;

  878.         // If not already a proc then we should try and make it one.
  879.         if (!(proc instanceof RubyProc)) {
  880.             proc = coerceProc(proc, runtime);
  881.         }

  883.         return getBlockFromProc(currentBlock, proc);
  884.     }

  886.     private static IRubyObject coerceProc(IRubyObject proc, Ruby runtime) throws RaiseException {
  887.         proc = TypeConverter.convertToType(proc, runtime.getProc(), "to_proc", false);

  889.         if (!(proc instanceof RubyProc)) {
  890.             throw runtime.newTypeError("wrong argument type " + proc.getMetaClass().getName() + " (expected Proc)");
  891.         }
  892.         return proc;
  893.     }

  895.     private static Block getBlockFromProc(Block currentBlock, IRubyObject proc) {
  896.         // TODO: Add safety check for taintedness
  897.         if (currentBlock != null && currentBlock.isGiven()) {
  898.             RubyProc procObject = currentBlock.getProcObject();
  899.             // The current block is already associated with proc.  No need to create a new one
  900.             if (procObject != null && procObject == proc) {
  901.                 return currentBlock;
  902.             }
  903.         }

  905.         return ((RubyProc) proc).getBlock();       
  906.     }
  907.     
  908.     public static Block getBlockFromBlockPassBody(IRubyObject proc, Block currentBlock) {
  909.         return getBlockFromBlockPassBody(proc.getRuntime(), proc, currentBlock);

  911.     }
  912.     
  913.     public static IRubyObject backref(ThreadContext context) {
  914.         IRubyObject backref = context.getBackRef();
  915.         
  916.         if(backref instanceof RubyMatchData) {
  917.             ((RubyMatchData)backref).use();
  918.         }
  919.         return backref;
  920.     }
  921.     
  922.     public static IRubyObject backrefLastMatch(ThreadContext context) {
  923.         IRubyObject backref = context.getBackRef();
  924.         
  925.         return RubyRegexp.last_match(backref);
  926.     }
  927.     
  928.     public static IRubyObject backrefMatchPre(ThreadContext context) {
  929.         IRubyObject backref = context.getBackRef();
  930.         
  931.         return RubyRegexp.match_pre(backref);
  932.     }
  933.     
  934.     public static IRubyObject backrefMatchPost(ThreadContext context) {
  935.         IRubyObject backref = context.getBackRef();
  936.         
  937.         return RubyRegexp.match_post(backref);
  938.     }
  939.     
  940.     public static IRubyObject backrefMatchLast(ThreadContext context) {
  941.         IRubyObject backref = context.getBackRef();
  942.         
  943.         return RubyRegexp.match_last(backref);
  944.     }

  946.     public static IRubyObject[] getArgValues(ThreadContext context) {
  947.         return context.getCurrentScope().getArgValues();
  948.     }
  949.     
  950.     public static IRubyObject callZSuper(Ruby runtime, ThreadContext context, Block block, IRubyObject self) {
  951.         // Has the method that is calling super received a block argument
  952.         if (!block.isGiven()) block = context.getCurrentFrame().getBlock(); 
  953.         
  954.         return Helpers.invokeSuper(context, self, context.getCurrentScope().getArgValues(), block);
  955.     }
  956.     
  957.     public static IRubyObject[] appendToObjectArray(IRubyObject[] array, IRubyObject add) {
  958.         IRubyObject[] newArray = new IRubyObject[array.length + 1];
  959.         System.arraycopy(array, 0, newArray, 0, array.length);
  960.         newArray[array.length] = add;
  961.         return newArray;
  962.     }
  963.     
  964.     public static IRubyObject breakLocalJumpError(Ruby runtime, IRubyObject value) {
  965.         throw runtime.newLocalJumpError(RubyLocalJumpError.Reason.BREAK, value, "unexpected break");
  966.     }
  967.     
  968.     public static IRubyObject[] concatObjectArrays(IRubyObject[] array, IRubyObject[] add) {
  969.         return toArray(array, add);
  970.     }
  971.     
  972.     public static IRubyObject[] toArray(IRubyObject[] array, IRubyObject... add) {
  973.         IRubyObject[] newArray = new IRubyObject[array.length + add.length];
  974.         System.arraycopy(array, 0, newArray, 0, array.length);
  975.         System.arraycopy(add, 0, newArray, array.length, add.length);
  976.         return newArray;
  977.     }
  978.     
  979.     public static IRubyObject[] toArray(IRubyObject obj, IRubyObject... rest) {
  980.         IRubyObject[] newArray = new IRubyObject[rest.length + 1];
  981.         newArray[0] = obj;
  982.         System.arraycopy(rest, 0, newArray, 1, rest.length);
  983.         return newArray;
  984.     }
  985.     
  986.     public static IRubyObject[] toArray(IRubyObject obj0, IRubyObject obj1, IRubyObject... rest) {
  987.         IRubyObject[] newArray = new IRubyObject[rest.length + 2];
  988.         newArray[0] = obj0;
  989.         newArray[1] = obj1;
  990.         System.arraycopy(rest, 0, newArray, 2, rest.length);
  991.         return newArray;
  992.     }
  993.     
  994.     public static IRubyObject[] toArray(IRubyObject obj0, IRubyObject obj1, IRubyObject obj2, IRubyObject... rest) {
  995.         IRubyObject[] newArray = new IRubyObject[rest.length + 3];
  996.         newArray[0] = obj0;
  997.         newArray[1] = obj1;
  998.         newArray[2] = obj2;
  999.         System.arraycopy(rest, 0, newArray, 3, rest.length);
  1000.         return newArray;
  1001.     }

  1003.     public static IRubyObject isExceptionHandled(RubyException currentException, IRubyObject[] exceptions, ThreadContext context) {
  1004.         for (int i = 0; i < exceptions.length; i++) {
  1005.             IRubyObject result = isExceptionHandled(currentException, exceptions[i], context);
  1006.             if (result.isTrue()) return result;
  1007.         }
  1008.         return context.runtime.getFalse();
  1009.     }

  1011.     public static IRubyObject isExceptionHandled(RubyException currentException, IRubyObject exception, ThreadContext context) {
  1012.         return isExceptionHandled((IRubyObject)currentException, exception, context);
  1013.     }

  1015.     public static IRubyObject isExceptionHandled(IRubyObject currentException, IRubyObject exception, ThreadContext context) {
  1016.         Ruby runtime = context.runtime;
  1017.         if (!runtime.getModule().isInstance(exception)) {
  1018.             throw runtime.newTypeError("class or module required for rescue clause");
  1019.         }
  1020.         IRubyObject result = invoke(context, exception, "===", currentException);
  1021.         if (result.isTrue()) return result;
  1022.         return runtime.getFalse();
  1023.     }
  1024.     
  1025.     public static IRubyObject isExceptionHandled(RubyException currentException, IRubyObject exception0, IRubyObject exception1, ThreadContext context) {
  1026.         IRubyObject result = isExceptionHandled(currentException, exception0, context);
  1027.         if (result.isTrue()) return result;
  1028.         return isExceptionHandled(currentException, exception1, context);
  1029.     }

  1031.     public static IRubyObject isExceptionHandled(RubyException currentException, IRubyObject exception0, IRubyObject exception1, IRubyObject exception2, ThreadContext context) {
  1032.         IRubyObject result = isExceptionHandled(currentException, exception0, context);
  1033.         if (result.isTrue()) return result;
  1034.         return isExceptionHandled(currentException, exception1, exception2, context);
  1035.     }

  1037.     public static boolean checkJavaException(Throwable throwable, IRubyObject catchable, ThreadContext context) {
  1038.         Ruby runtime = context.runtime;
  1039.         if (
  1040.                 // rescue exception needs to catch Java exceptions
  1041.                 runtime.getException() == catchable ||

  1043.                 // rescue Object needs to catch Java exceptions
  1044.                 runtime.getObject() == catchable ||

  1046.                 // rescue StandardError needs to catch Java exceptions
  1047.                 runtime.getStandardError() == catchable) {

  1049.             if (throwable instanceof RaiseException) {
  1050.                 return isExceptionHandled(((RaiseException)throwable).getException(), catchable, context).isTrue();
  1051.             }

  1053.             // let Ruby exceptions decide if they handle it
  1054.             return isExceptionHandled(JavaUtil.convertJavaToUsableRubyObject(runtime, throwable), catchable, context).isTrue();

  1056.         } else if (runtime.getNativeException() == catchable) {
  1057.             // NativeException catches Java exceptions, lazily creating the wrapper
  1058.             return true;

  1060.         } else if (catchable instanceof RubyClass && catchable.getInstanceVariables().hasInstanceVariable("@java_class")) {
  1061.             RubyClass rubyClass = (RubyClass)catchable;
  1062.             JavaClass javaClass = (JavaClass)rubyClass.getInstanceVariable("@java_class");
  1063.             if (javaClass != null) {
  1064.                 Class cls = javaClass.javaClass();
  1065.                 if (cls.isInstance(throwable)) {
  1066.                     return true;
  1067.                 }
  1068.             }

  1070.         } else if (catchable instanceof RubyModule) {
  1071.             IRubyObject exception = JavaUtil.convertJavaToUsableRubyObject(runtime, throwable);
  1072.             IRubyObject result = invoke(context, catchable, "===", exception);
  1073.             return result.isTrue();

  1075.         }

  1077.         return false;
  1078.     }
  1079.     
  1080.     public static IRubyObject isJavaExceptionHandled(Throwable currentThrowable, IRubyObject[] throwables, ThreadContext context) {
  1081.         if (currentThrowable instanceof Unrescuable) {
  1082.             throwException(currentThrowable);
  1083.         }

  1085.         if (currentThrowable instanceof RaiseException) {
  1086.             return isExceptionHandled(((RaiseException)currentThrowable).getException(), throwables, context);
  1087.         } else {
  1088.             if (throwables.length == 0) {
  1089.                 // no rescue means StandardError, which rescues Java exceptions
  1090.                 return context.runtime.getTrue();
  1091.             } else {
  1092.                 for (int i = 0; i < throwables.length; i++) {
  1093.                     if (checkJavaException(currentThrowable, throwables[i], context)) {
  1094.                         return context.runtime.getTrue();
  1095.                     }
  1096.                 }
  1097.             }

  1099.             return context.runtime.getFalse();
  1100.         }
  1101.     }

  1103.     public static IRubyObject isJavaExceptionHandled(Throwable currentThrowable, IRubyObject throwable, ThreadContext context) {
  1104.         if (currentThrowable instanceof Unrescuable) {
  1105.             throwException(currentThrowable);
  1106.         }

  1108.         if (currentThrowable instanceof RaiseException) {
  1109.             return isExceptionHandled(((RaiseException)currentThrowable).getException(), throwable, context);
  1110.         } else {
  1111.             if (checkJavaException(currentThrowable, throwable, context)) {
  1112.                 return context.runtime.getTrue();
  1113.             }

  1115.             return context.runtime.getFalse();
  1116.         }
  1117.     }

  1119.     public static IRubyObject isJavaExceptionHandled(Throwable currentThrowable, IRubyObject throwable0, IRubyObject throwable1, ThreadContext context) {
  1120.         if (currentThrowable instanceof Unrescuable) {
  1121.             throwException(currentThrowable);
  1122.         }

  1124.         if (currentThrowable instanceof RaiseException) {
  1125.             return isExceptionHandled(((RaiseException)currentThrowable).getException(), throwable0, throwable1, context);
  1126.         } else {
  1127.             if (checkJavaException(currentThrowable, throwable0, context)) {
  1128.                 return context.runtime.getTrue();
  1129.             }
  1130.             if (checkJavaException(currentThrowable, throwable1, context)) {
  1131.                 return context.runtime.getTrue();
  1132.             }

  1134.             return context.runtime.getFalse();
  1135.         }
  1136.     }

  1138.     public static IRubyObject isJavaExceptionHandled(Throwable currentThrowable, IRubyObject throwable0, IRubyObject throwable1, IRubyObject throwable2, ThreadContext context) {
  1139.         if (currentThrowable instanceof Unrescuable) {
  1140.             throwException(currentThrowable);
  1141.         }
  1142.         
  1143.         if (currentThrowable instanceof RaiseException) {
  1144.             return isExceptionHandled(((RaiseException)currentThrowable).getException(), throwable0, throwable1, throwable2, context);
  1145.         } else {
  1146.             if (checkJavaException(currentThrowable, throwable0, context)) {
  1147.                 return context.runtime.getTrue();
  1148.             }
  1149.             if (checkJavaException(currentThrowable, throwable1, context)) {
  1150.                 return context.runtime.getTrue();
  1151.             }
  1152.             if (checkJavaException(currentThrowable, throwable2, context)) {
  1153.                 return context.runtime.getTrue();
  1154.             }

  1156.             return context.runtime.getFalse();
  1157.         }
  1158.     }

  1160.     public static void storeExceptionInErrorInfo(Throwable currentThrowable, ThreadContext context) {
  1161.         IRubyObject exception = null;
  1162.         if (currentThrowable instanceof RaiseException) {
  1163.             exception = ((RaiseException)currentThrowable).getException();
  1164.         } else {
  1165.             exception = JavaUtil.convertJavaToUsableRubyObject(context.runtime, currentThrowable);
  1166.         }
  1167.         context.setErrorInfo(exception);
  1168.     }

  1170.     public static void storeNativeExceptionInErrorInfo(Throwable currentThrowable, ThreadContext context) {
  1171.         IRubyObject exception = null;
  1172.         if (currentThrowable instanceof RaiseException) {
  1173.             exception = ((RaiseException)currentThrowable).getException();
  1174.         } else {
  1175.             Ruby runtime = context.runtime;

  1177.             // wrap Throwable in a NativeException object
  1178.             exception = new NativeException(runtime, runtime.getNativeException(), currentThrowable);
  1179.             ((NativeException)exception).prepareIntegratedBacktrace(context, currentThrowable.getStackTrace());
  1180.         }
  1181.         context.setErrorInfo(exception);
  1182.     }

  1184.     public static void clearErrorInfo(ThreadContext context) {
  1185.         context.setErrorInfo(context.runtime.getNil());
  1186.     }
  1187.     
  1188.     public static void checkSuperDisabledOrOutOfMethod(ThreadContext context) {
  1189.         checkSuperDisabledOrOutOfMethod(context, context.getFrameKlazz(), context.getFrameName());
  1190.     }

  1192.     public static void checkSuperDisabledOrOutOfMethod(ThreadContext context, RubyModule klass, String name) {
  1193.         if (klass == null) {
  1194.             if (name != null) {
  1195.                 throw context.runtime.newNameError("superclass method '" + name + "' disabled", name);
  1196.             } else {
  1197.                 throw context.runtime.newNoMethodError("super called outside of method", null, context.nil);
  1198.             }
  1199.         }
  1200.     }
  1201.     
  1202.     public static Block ensureSuperBlock(Block given, Block parent) {
  1203.         if (!given.isGiven()) {
  1204.             return parent;
  1205.         }
  1206.         return given;
  1207.     }
  1208.     
  1209.     public static RubyModule findImplementerIfNecessary(RubyModule clazz, RubyModule implementationClass) {
  1210.         if (implementationClass.needsImplementer()) {
  1211.             // modules are included with a shim class; we must find that shim to handle super() appropriately
  1212.             return clazz.findImplementer(implementationClass);
  1213.         } else {
  1214.             // classes are directly in the hierarchy, so no special logic is necessary for implementer
  1215.             return implementationClass;
  1216.         }
  1217.     }
  1218.     
  1219.     public static RubyArray createSubarray(RubyArray input, int start) {
  1220.         return (RubyArray)input.subseqLight(start, input.size() - start);
  1221.     }

  1223.     public static RubyArray createSubarray(RubyArray input, int start, int post) {
  1224.         return (RubyArray)input.subseqLight(start, input.size() - post - start);
  1225.     }
  1226.     
  1227.     public static RubyArray createSubarray(IRubyObject[] input, Ruby runtime, int start) {
  1228.         if (start >= input.length) {
  1229.             return RubyArray.newEmptyArray(runtime);
  1230.         } else {
  1231.             return RubyArray.newArrayNoCopy(runtime, input, start);
  1232.         }
  1233.     }

  1235.     public static RubyArray createSubarray(IRubyObject[] input, Ruby runtime, int start, int exclude) {
  1236.         int length = input.length - exclude - start;
  1237.         if (length <= 0) {
  1238.             return RubyArray.newEmptyArray(runtime);
  1239.         } else {
  1240.             return RubyArray.newArrayNoCopy(runtime, input, start, length);
  1241.         }
  1242.     }

  1244.     public static IRubyObject elementOrNull(IRubyObject[] input, int element) {
  1245.         if (element >= input.length) {
  1246.             return null;
  1247.         } else {
  1248.             return input[element];
  1249.         }
  1250.     }

  1252.     public static IRubyObject optElementOrNull(IRubyObject[] input, int element, int postCount) {
  1253.         if (element + postCount >= input.length) {
  1254.             return null;
  1255.         } else {
  1256.             return input[element];
  1257.         }
  1258.     }

  1260.     public static IRubyObject elementOrNil(IRubyObject[] input, int element, IRubyObject nil) {
  1261.         if (element >= input.length) {
  1262.             return nil;
  1263.         } else {
  1264.             return input[element];
  1265.         }
  1266.     }

  1268.     public static IRubyObject postElementOrNil(IRubyObject[] input, int postCount, int postIndex, IRubyObject nil) {
  1269.         int aryIndex = input.length - postCount + postIndex;
  1270.         if (aryIndex >= input.length || aryIndex < 0) {
  1271.             return nil;
  1272.         } else {
  1273.             return input[aryIndex];
  1274.         }
  1275.     }
  1276.     
  1277.     public static RubyBoolean isWhenTriggered(IRubyObject expression, IRubyObject expressionsObject, ThreadContext context) {
  1278.         RubyArray expressions = Helpers.splatValue(expressionsObject);
  1279.         for (int j = 0,k = expressions.getLength(); j < k; j++) {
  1280.             IRubyObject condition = expressions.eltInternal(j);

  1282.             if ((expression != null && condition.callMethod(context, "===", expression).isTrue()) ||
  1283.                     (expression == null && condition.isTrue())) {
  1284.                 return context.runtime.getTrue();
  1285.             }
  1286.         }

  1288.         return context.runtime.getFalse();
  1289.     }
  1290.     
  1291.     public static IRubyObject setConstantInModule(ThreadContext context, String name, IRubyObject value, IRubyObject module) {
  1292.         if (!(module instanceof RubyModule)) {
  1293.             throw context.runtime.newTypeError(module.toString() + " is not a class/module");
  1294.         }
  1295.         ((RubyModule)module).setConstant(name, value);

  1297.         return value;
  1298.     }

  1300.     public static IRubyObject setConstantInCurrent(IRubyObject value, ThreadContext context, String name) {
  1301.         return context.getCurrentStaticScope().setConstant(name, value);
  1302.     }

  1304.     public static IRubyObject retryJump() {
  1305.         throw JumpException.RETRY_JUMP;
  1306.     }

  1308.     public static IRubyObject redoJump() {
  1309.         throw JumpException.REDO_JUMP;
  1310.     }

  1312.     public static IRubyObject redoLocalJumpError(Ruby runtime) {
  1313.         throw runtime.newLocalJumpError(RubyLocalJumpError.Reason.REDO, runtime.getNil(), "unexpected redo");
  1314.     }

  1316.     public static IRubyObject nextJump(IRubyObject value) {
  1317.         if (value.isNil()) throw JumpException.NEXT_JUMP;

  1319.         throw new JumpException.NextJump(value);
  1320.     }
  1321.     
  1322.     public static IRubyObject nextLocalJumpError(Ruby runtime, IRubyObject value) {
  1323.         throw runtime.newLocalJumpError(RubyLocalJumpError.Reason.NEXT, value, "unexpected next");
  1324.     }
  1325.     
  1326.     public static final int MAX_SPECIFIC_ARITY_OBJECT_ARRAY = 10;
  1327.     
  1328.     public static IRubyObject[] anewarrayIRubyObjects(int size) {
  1329.         return new IRubyObject[size];
  1330.     }
  1331.     
  1332.     public static IRubyObject[] aastoreIRubyObjects(IRubyObject[] ary, IRubyObject one, int start) {
  1333.         ary[start] = one;
  1334.         return ary;
  1335.     }
  1336.     
  1337.     public static IRubyObject[] aastoreIRubyObjects(IRubyObject[] ary, IRubyObject one, IRubyObject two, int start) {
  1338.         ary[start] = one;
  1339.         ary[start+1] = two;
  1340.         return ary;
  1341.     }
  1342.     
  1343.     public static IRubyObject[] aastoreIRubyObjects(IRubyObject[] ary, IRubyObject one, IRubyObject two, IRubyObject three, int start) {
  1344.         ary[start] = one;
  1345.         ary[start+1] = two;
  1346.         ary[start+2] = three;
  1347.         return ary;
  1348.     }
  1349.     
  1350.     public static IRubyObject[] aastoreIRubyObjects(IRubyObject[] ary, IRubyObject one, IRubyObject two, IRubyObject three, IRubyObject four, int start) {
  1351.         ary[start] = one;
  1352.         ary[start+1] = two;
  1353.         ary[start+2] = three;
  1354.         ary[start+3] = four;
  1355.         return ary;
  1356.     }
  1357.     
  1358.     public static IRubyObject[] aastoreIRubyObjects(IRubyObject[] ary, IRubyObject one, IRubyObject two, IRubyObject three, IRubyObject four, IRubyObject five, int start) {
  1359.         ary[start] = one;
  1360.         ary[start+1] = two;
  1361.         ary[start+2] = three;
  1362.         ary[start+3] = four;
  1363.         ary[start+4] = five;
  1364.         return ary;
  1365.     }
  1366.     
  1367.     public static IRubyObject[] aastoreIRubyObjects(IRubyObject[] ary, IRubyObject one, IRubyObject two, IRubyObject three, IRubyObject four, IRubyObject five, IRubyObject six, int start) {
  1368.         ary[start] = one;
  1369.         ary[start+1] = two;
  1370.         ary[start+2] = three;
  1371.         ary[start+3] = four;
  1372.         ary[start+4] = five;
  1373.         ary[start+5] = six;
  1374.         return ary;
  1375.     }
  1376.     
  1377.     public static IRubyObject[] aastoreIRubyObjects(IRubyObject[] ary, IRubyObject one, IRubyObject two, IRubyObject three, IRubyObject four, IRubyObject five, IRubyObject six, IRubyObject seven, int start) {
  1378.         ary[start] = one;
  1379.         ary[start+1] = two;
  1380.         ary[start+2] = three;
  1381.         ary[start+3] = four;
  1382.         ary[start+4] = five;
  1383.         ary[start+5] = six;
  1384.         ary[start+6] = seven;
  1385.         return ary;
  1386.     }
  1387.     
  1388.     public static IRubyObject[] aastoreIRubyObjects(IRubyObject[] ary, IRubyObject one, IRubyObject two, IRubyObject three, IRubyObject four, IRubyObject five, IRubyObject six, IRubyObject seven, IRubyObject eight, int start) {
  1389.         ary[start] = one;
  1390.         ary[start+1] = two;
  1391.         ary[start+2] = three;
  1392.         ary[start+3] = four;
  1393.         ary[start+4] = five;
  1394.         ary[start+5] = six;
  1395.         ary[start+6] = seven;
  1396.         ary[start+7] = eight;
  1397.         return ary;
  1398.     }
  1399.     
  1400.     public static IRubyObject[] aastoreIRubyObjects(IRubyObject[] ary, IRubyObject one, IRubyObject two, IRubyObject three, IRubyObject four, IRubyObject five, IRubyObject six, IRubyObject seven, IRubyObject eight, IRubyObject nine, int start) {
  1401.         ary[start] = one;
  1402.         ary[start+1] = two;
  1403.         ary[start+2] = three;
  1404.         ary[start+3] = four;
  1405.         ary[start+4] = five;
  1406.         ary[start+5] = six;
  1407.         ary[start+6] = seven;
  1408.         ary[start+7] = eight;
  1409.         ary[start+8] = nine;
  1410.         return ary;
  1411.     }
  1412.     
  1413.     public static IRubyObject[] aastoreIRubyObjects(IRubyObject[] ary, IRubyObject one, IRubyObject two, IRubyObject three, IRubyObject four, IRubyObject five, IRubyObject six, IRubyObject seven, IRubyObject eight, IRubyObject nine, IRubyObject ten, int start) {
  1414.         ary[start] = one;
  1415.         ary[start+1] = two;
  1416.         ary[start+2] = three;
  1417.         ary[start+3] = four;
  1418.         ary[start+4] = five;
  1419.         ary[start+5] = six;
  1420.         ary[start+6] = seven;
  1421.         ary[start+7] = eight;
  1422.         ary[start+8] = nine;
  1423.         ary[start+9] = ten;
  1424.         return ary;
  1425.     }
  1426.     
  1427.     public static IRubyObject[] constructObjectArray(IRubyObject one) {
  1428.         return new IRubyObject[] {one};
  1429.     }
  1430.     
  1431.     public static IRubyObject[] constructObjectArray(IRubyObject one, IRubyObject two) {
  1432.         return new IRubyObject[] {one, two};
  1433.     }
  1434.     
  1435.     public static IRubyObject[] constructObjectArray(IRubyObject one, IRubyObject two, IRubyObject three) {
  1436.         return new IRubyObject[] {one, two, three};
  1437.     }
  1438.     
  1439.     public static IRubyObject[] constructObjectArray(IRubyObject one, IRubyObject two, IRubyObject three, IRubyObject four) {
  1440.         return new IRubyObject[] {one, two, three, four};
  1441.     }
  1442.     
  1443.     public static IRubyObject[] constructObjectArray(IRubyObject one, IRubyObject two, IRubyObject three, IRubyObject four, IRubyObject five) {
  1444.         return new IRubyObject[] {one, two, three, four, five};
  1445.     }
  1446.     
  1447.     public static IRubyObject[] constructObjectArray(IRubyObject one, IRubyObject two, IRubyObject three, IRubyObject four, IRubyObject five, IRubyObject six) {
  1448.         return new IRubyObject[] {one, two, three, four, five, six};
  1449.     }
  1450.     
  1451.     public static IRubyObject[] constructObjectArray(IRubyObject one, IRubyObject two, IRubyObject three, IRubyObject four, IRubyObject five, IRubyObject six, IRubyObject seven) {
  1452.         return new IRubyObject[] {one, two, three, four, five, six, seven};
  1453.     }
  1454.     
  1455.     public static IRubyObject[] constructObjectArray(IRubyObject one, IRubyObject two, IRubyObject three, IRubyObject four, IRubyObject five, IRubyObject six, IRubyObject seven, IRubyObject eight) {
  1456.         return new IRubyObject[] {one, two, three, four, five, six, seven, eight};
  1457.     }
  1458.     
  1459.     public static IRubyObject[] constructObjectArray(IRubyObject one, IRubyObject two, IRubyObject three, IRubyObject four, IRubyObject five, IRubyObject six, IRubyObject seven, IRubyObject eight, IRubyObject nine) {
  1460.         return new IRubyObject[] {one, two, three, four, five, six, seven, eight, nine};
  1461.     }
  1462.     
  1463.     public static IRubyObject[] constructObjectArray(IRubyObject one, IRubyObject two, IRubyObject three, IRubyObject four, IRubyObject five, IRubyObject six, IRubyObject seven, IRubyObject eight, IRubyObject nine, IRubyObject ten) {
  1464.         return new IRubyObject[] {one, two, three, four, five, six, seven, eight, nine, ten};
  1465.     }

  1467.     public static RubyArray constructRubyArray(Ruby runtime, IRubyObject one) {
  1468.         return RubyArray.newArrayLight(runtime, one);
  1469.     }

  1471.     public static RubyArray constructRubyArray(Ruby runtime, IRubyObject one, IRubyObject two) {
  1472.         return RubyArray.newArrayLight(runtime, one, two);
  1473.     }

  1475.     public static RubyArray constructRubyArray(Ruby runtime, IRubyObject one, IRubyObject two, IRubyObject three) {
  1476.         return RubyArray.newArrayLight(runtime, one, two, three);
  1477.     }

  1479.     public static RubyArray constructRubyArray(Ruby runtime, IRubyObject one, IRubyObject two, IRubyObject three, IRubyObject four) {
  1480.         return RubyArray.newArrayLight(runtime, one, two, three, four);
  1481.     }

  1483.     public static RubyArray constructRubyArray(Ruby runtime, IRubyObject one, IRubyObject two, IRubyObject three, IRubyObject four, IRubyObject five) {
  1484.         return RubyArray.newArrayLight(runtime, one, two, three, four, five);
  1485.     }

  1487.     public static RubyArray constructRubyArray(Ruby runtime, IRubyObject one, IRubyObject two, IRubyObject three, IRubyObject four, IRubyObject five, IRubyObject six) {
  1488.         return RubyArray.newArrayLight(runtime, one, two, three, four, five, six);
  1489.     }

  1491.     public static RubyArray constructRubyArray(Ruby runtime, IRubyObject one, IRubyObject two, IRubyObject three, IRubyObject four, IRubyObject five, IRubyObject six, IRubyObject seven) {
  1492.         return RubyArray.newArrayLight(runtime, one, two, three, four, five, six, seven);
  1493.     }

  1495.     public static RubyArray constructRubyArray(Ruby runtime, IRubyObject one, IRubyObject two, IRubyObject three, IRubyObject four, IRubyObject five, IRubyObject six, IRubyObject seven, IRubyObject eight) {
  1496.         return RubyArray.newArrayLight(runtime, one, two, three, four, five, six, seven, eight);
  1497.     }

  1499.     public static RubyArray constructRubyArray(Ruby runtime, IRubyObject one, IRubyObject two, IRubyObject three, IRubyObject four, IRubyObject five, IRubyObject six, IRubyObject seven, IRubyObject eight, IRubyObject nine) {
  1500.         return RubyArray.newArrayLight(runtime, one, two, three, four, five, six, seven, eight, nine);
  1501.     }

  1503.     public static RubyArray constructRubyArray(Ruby runtime, IRubyObject one, IRubyObject two, IRubyObject three, IRubyObject four, IRubyObject five, IRubyObject six, IRubyObject seven, IRubyObject eight, IRubyObject nine, IRubyObject ten) {
  1504.         return RubyArray.newArrayLight(runtime, one, two, three, four, five, six, seven, eight, nine, ten);
  1505.     }
  1506.     
  1507.     public static String[] constructStringArray(String one) {
  1508.         return new String[] {one};
  1509.     }
  1510.     
  1511.     public static String[] constructStringArray(String one, String two) {
  1512.         return new String[] {one, two};
  1513.     }
  1514.     
  1515.     public static String[] constructStringArray(String one, String two, String three) {
  1516.         return new String[] {one, two, three};
  1517.     }
  1518.     
  1519.     public static String[] constructStringArray(String one, String two, String three, String four) {
  1520.         return new String[] {one, two, three, four};
  1521.     }
  1522.     
  1523.     public static String[] constructStringArray(String one, String two, String three, String four, String five) {
  1524.         return new String[] {one, two, three, four, five};
  1525.     }
  1526.     
  1527.     public static String[] constructStringArray(String one, String two, String three, String four, String five, String six) {
  1528.         return new String[] {one, two, three, four, five, six};
  1529.     }
  1530.     
  1531.     public static String[] constructStringArray(String one, String two, String three, String four, String five, String six, String seven) {
  1532.         return new String[] {one, two, three, four, five, six, seven};
  1533.     }
  1534.     
  1535.     public static String[] constructStringArray(String one, String two, String three, String four, String five, String six, String seven, String eight) {
  1536.         return new String[] {one, two, three, four, five, six, seven, eight};
  1537.     }
  1538.     
  1539.     public static String[] constructStringArray(String one, String two, String three, String four, String five, String six, String seven, String eight, String nine) {
  1540.         return new String[] {one, two, three, four, five, six, seven, eight, nine};
  1541.     }
  1542.     
  1543.     public static String[] constructStringArray(String one, String two, String three, String four, String five, String six, String seven, String eight, String nine, String ten) {
  1544.         return new String[] {one, two, three, four, five, six, seven, eight, nine, ten};
  1545.     }

  1547.     public static final int MAX_SPECIFIC_ARITY_HASH = 5;

  1549.     public static RubyHash constructHash(Ruby runtime,
  1550.                                          IRubyObject key1, IRubyObject value1, boolean prepareString1) {
  1551.         RubyHash hash = RubyHash.newHash(runtime);
  1552.         hash.fastASet(runtime, key1, value1, prepareString1);
  1553.         return hash;
  1554.     }

  1556.     public static RubyHash constructHash(Ruby runtime,
  1557.                                          IRubyObject key1, IRubyObject value1, boolean prepareString1,
  1558.                                          IRubyObject key2, IRubyObject value2, boolean prepareString2) {
  1559.         RubyHash hash = RubyHash.newHash(runtime);
  1560.         hash.fastASet(runtime, key1, value1, prepareString1);
  1561.         hash.fastASet(runtime, key2, value2, prepareString2);
  1562.         return hash;
  1563.     }

  1565.     public static RubyHash constructHash(Ruby runtime,
  1566.                                          IRubyObject key1, IRubyObject value1, boolean prepareString1,
  1567.                                          IRubyObject key2, IRubyObject value2, boolean prepareString2,
  1568.                                          IRubyObject key3, IRubyObject value3, boolean prepareString3) {
  1569.         RubyHash hash = RubyHash.newHash(runtime);
  1570.         hash.fastASet(runtime, key1, value1, prepareString1);
  1571.         hash.fastASet(runtime, key2, value2, prepareString2);
  1572.         hash.fastASet(runtime, key3, value3, prepareString3);
  1573.         return hash;
  1574.     }

  1576.     public static RubyHash constructHash(Ruby runtime,
  1577.                                          IRubyObject key1, IRubyObject value1, boolean prepareString1,
  1578.                                          IRubyObject key2, IRubyObject value2, boolean prepareString2,
  1579.                                          IRubyObject key3, IRubyObject value3, boolean prepareString3,
  1580.                                          IRubyObject key4, IRubyObject value4, boolean prepareString4) {
  1581.         RubyHash hash = RubyHash.newHash(runtime);
  1582.         hash.fastASet(runtime, key1, value1, prepareString1);
  1583.         hash.fastASet(runtime, key2, value2, prepareString2);
  1584.         hash.fastASet(runtime, key3, value3, prepareString3);
  1585.         hash.fastASet(runtime, key4, value4, prepareString4);
  1586.         return hash;
  1587.     }

  1589.     public static RubyHash constructHash(Ruby runtime,
  1590.                                          IRubyObject key1, IRubyObject value1, boolean prepareString1,
  1591.                                          IRubyObject key2, IRubyObject value2, boolean prepareString2,
  1592.                                          IRubyObject key3, IRubyObject value3, boolean prepareString3,
  1593.                                          IRubyObject key4, IRubyObject value4, boolean prepareString4,
  1594.                                          IRubyObject key5, IRubyObject value5, boolean prepareString5) {
  1595.         RubyHash hash = RubyHash.newHash(runtime);
  1596.         hash.fastASet(runtime, key1, value1, prepareString1);
  1597.         hash.fastASet(runtime, key2, value2, prepareString2);
  1598.         hash.fastASet(runtime, key3, value3, prepareString3);
  1599.         hash.fastASet(runtime, key4, value4, prepareString4);
  1600.         hash.fastASet(runtime, key5, value5, prepareString5);
  1601.         return hash;
  1602.     }

  1604.     public static RubyHash constructSmallHash(Ruby runtime,
  1605.                                               IRubyObject key1, IRubyObject value1, boolean prepareString1) {
  1606.         RubyHash hash = RubyHash.newSmallHash(runtime);
  1607.         hash.fastASetSmall(runtime, key1, value1, prepareString1);
  1608.         return hash;
  1609.     }

  1611.     public static RubyHash constructSmallHash(Ruby runtime,
  1612.                                               IRubyObject key1, IRubyObject value1, boolean prepareString1,
  1613.                                               IRubyObject key2, IRubyObject value2, boolean prepareString2) {
  1614.         RubyHash hash = RubyHash.newSmallHash(runtime);
  1615.         hash.fastASetSmall(runtime, key1, value1, prepareString1);
  1616.         hash.fastASetSmall(runtime, key2, value2, prepareString2);
  1617.         return hash;
  1618.     }

  1620.     public static RubyHash constructSmallHash(Ruby runtime,
  1621.                                               IRubyObject key1, IRubyObject value1, boolean prepareString1,
  1622.                                               IRubyObject key2, IRubyObject value2, boolean prepareString2,
  1623.                                               IRubyObject key3, IRubyObject value3, boolean prepareString3) {
  1624.         RubyHash hash = RubyHash.newSmallHash(runtime);
  1625.         hash.fastASetSmall(runtime, key1, value1, prepareString1);
  1626.         hash.fastASetSmall(runtime, key2, value2, prepareString2);
  1627.         hash.fastASetSmall(runtime, key3, value3, prepareString3);
  1628.         return hash;
  1629.     }

  1631.     public static RubyHash constructSmallHash(Ruby runtime,
  1632.                                               IRubyObject key1, IRubyObject value1, boolean prepareString1,
  1633.                                               IRubyObject key2, IRubyObject value2, boolean prepareString2,
  1634.                                               IRubyObject key3, IRubyObject value3, boolean prepareString3,
  1635.                                               IRubyObject key4, IRubyObject value4, boolean prepareString4) {
  1636.         RubyHash hash = RubyHash.newSmallHash(runtime);
  1637.         hash.fastASetSmall(runtime, key1, value1, prepareString1);
  1638.         hash.fastASetSmall(runtime, key2, value2, prepareString2);
  1639.         hash.fastASetSmall(runtime, key3, value3, prepareString3);
  1640.         hash.fastASetSmall(runtime, key4, value4, prepareString4);
  1641.         return hash;
  1642.     }

  1644.     public static RubyHash constructSmallHash(Ruby runtime,
  1645.                                               IRubyObject key1, IRubyObject value1, boolean prepareString1,
  1646.                                               IRubyObject key2, IRubyObject value2, boolean prepareString2,
  1647.                                               IRubyObject key3, IRubyObject value3, boolean prepareString3,
  1648.                                               IRubyObject key4, IRubyObject value4, boolean prepareString4,
  1649.                                               IRubyObject key5, IRubyObject value5, boolean prepareString5) {
  1650.         RubyHash hash = RubyHash.newSmallHash(runtime);
  1651.         hash.fastASetSmall(runtime, key1, value1, prepareString1);
  1652.         hash.fastASetSmall(runtime, key2, value2, prepareString2);
  1653.         hash.fastASetSmall(runtime, key3, value3, prepareString3);
  1654.         hash.fastASetSmall(runtime, key4, value4, prepareString4);
  1655.         hash.fastASetSmall(runtime, key5, value5, prepareString5);
  1656.         return hash;
  1657.     }

  1659.     public static IRubyObject undefMethod(ThreadContext context, Object nameArg) {
  1660.         RubyModule module = null; // context.getRubyClass();
  1661.         String name = (nameArg instanceof String) ?
  1662.             (String) nameArg : nameArg.toString();

  1664.         if (module == null) {
  1665.             throw context.runtime.newTypeError("No class to undef method '" + name + "'.");
  1666.         }

  1668.         module.undef(context, name);

  1670.         return context.runtime.getNil();
  1671.     }
  1672.     
  1673.     public static IRubyObject defineAlias(ThreadContext context, IRubyObject self, Object newNameArg, Object oldNameArg) {
  1674.         Ruby runtime = context.runtime;
  1675.         RubyModule module = null; // context.getRubyClass();
  1676.    
  1677.         if (module == null || self instanceof RubyFixnum || self instanceof RubySymbol){
  1678.             throw runtime.newTypeError("no class to make alias");
  1679.         }

  1681.         String newName = newNameArg.toString();
  1682.         String oldName = oldNameArg.toString();

  1684.         module.defineAlias(newName, oldName);
  1685.         module.callMethod(context, "method_added", runtime.newSymbol(newName));
  1686.    
  1687.         return runtime.getNil();
  1688.     }
  1689.     
  1690.     public static IRubyObject negate(IRubyObject value, Ruby runtime) {
  1691.         if (value.isTrue()) return runtime.getFalse();
  1692.         return runtime.getTrue();
  1693.     }
  1694.     
  1695.     public static IRubyObject stringOrNil(ByteList value, ThreadContext context) {
  1696.         if (value == null) return context.nil;
  1697.         return RubyString.newStringShared(context.runtime, value);
  1698.     }
  1699.     
  1700.     public static StaticScope preLoad(ThreadContext context, String[] varNames) {
  1701.         StaticScope staticScope = context.runtime.getStaticScopeFactory().newLocalScope(null, varNames);
  1702.         preLoadCommon(context, staticScope, false);

  1704.         return staticScope;
  1705.     }

  1707.     public static StaticScope preLoad(ThreadContext context, String scopeString, boolean wrap) {
  1708.         StaticScope staticScope = decodeScope(context, null, scopeString);
  1709.         preLoadCommon(context, staticScope, wrap);

  1711.         return staticScope;
  1712.     }

  1714.     public static void preLoadCommon(ThreadContext context, StaticScope staticScope, boolean wrap) {
  1715.         if (wrap) {
  1716.             staticScope.setModule(RubyModule.newModule(context.runtime));
  1717.         } else {
  1718.             staticScope.setModule(context.runtime.getObject());
  1719.         }
  1720.         DynamicScope scope = DynamicScope.newDynamicScope(staticScope);

  1722.         // Each root node has a top-level scope that we need to push
  1723.         context.preScopedBody(scope);
  1724.         context.preNodeEval(context.runtime.getTopSelf());
  1725.     }
  1726.     
  1727.     public static void postLoad(ThreadContext context) {
  1728.         context.postNodeEval();
  1729.         context.postScopedBody();
  1730.     }
  1731.     
  1732.     public static void registerEndBlock(Block block, Ruby runtime) {
  1733.         runtime.pushExitBlock(runtime.newProc(Block.Type.LAMBDA, block));
  1734.     }
  1735.     
  1736.     public static IRubyObject match3(RubyRegexp regexp, IRubyObject value, ThreadContext context) {
  1737.         if (value instanceof RubyString) {
  1738.             return regexp.op_match(context, value);
  1739.         } else {
  1740.             return value.callMethod(context, "=~", regexp);
  1741.         }
  1742.     }

  1744.     public static IRubyObject match3_19(RubyRegexp regexp, IRubyObject value, ThreadContext context) {
  1745.         if (value instanceof RubyString) {
  1746.             return regexp.op_match19(context, value);
  1747.         } else {
  1748.             return value.callMethod(context, "=~", regexp);
  1749.         }
  1750.     }
  1751.     
  1752.     public static IRubyObject getErrorInfo(Ruby runtime) {
  1753.         return runtime.getGlobalVariables().get("$!");
  1754.     }
  1755.     
  1756.     public static void setErrorInfo(Ruby runtime, IRubyObject error) {
  1757.         runtime.getGlobalVariables().set("$!", error);
  1758.     }

  1760.     public static IRubyObject setLastLine(Ruby runtime, ThreadContext context, IRubyObject value) {
  1761.         return context.setLastLine(value);
  1762.     }

  1764.     public static IRubyObject getLastLine(Ruby runtime, ThreadContext context) {
  1765.         return context.getLastLine();
  1766.     }

  1768.     public static IRubyObject setBackref(Ruby runtime, ThreadContext context, IRubyObject value) {
  1769.         if (!value.isNil() && !(value instanceof RubyMatchData)) throw runtime.newTypeError(value, runtime.getMatchData());
  1770.         return context.setBackRef(value);
  1771.     }

  1773.     public static IRubyObject getBackref(Ruby runtime, ThreadContext context) {
  1774.         IRubyObject backref = context.getBackRef();
  1775.         if (backref instanceof RubyMatchData) ((RubyMatchData)backref).use();
  1776.         return backref;
  1777.     }
  1778.     
  1779.     public static IRubyObject preOpAsgnWithOrAnd(IRubyObject receiver, ThreadContext context, IRubyObject self, CallSite varSite) {
  1780.         return varSite.call(context, self, receiver);
  1781.     }
  1782.     
  1783.     public static IRubyObject postOpAsgnWithOrAnd(IRubyObject receiver, IRubyObject value, ThreadContext context, IRubyObject self, CallSite varAsgnSite) {
  1784.         varAsgnSite.call(context, self, receiver, value);
  1785.         return value;
  1786.     }
  1787.     
  1788.     public static IRubyObject opAsgnWithMethod(ThreadContext context, IRubyObject self, IRubyObject receiver, IRubyObject arg, CallSite varSite, CallSite opSite, CallSite opAsgnSite) {
  1789.         IRubyObject var = varSite.call(context, self, receiver);
  1790.         IRubyObject result = opSite.call(context, self, var, arg);
  1791.         opAsgnSite.call(context, self, receiver, result);

  1793.         return result;
  1794.     }
  1795.     
  1796.     public static IRubyObject opElementAsgnWithMethod(ThreadContext context, IRubyObject self, IRubyObject receiver, IRubyObject value, CallSite elementSite, CallSite opSite, CallSite elementAsgnSite) {
  1797.         IRubyObject var = elementSite.call(context, self, receiver);
  1798.         IRubyObject result = opSite.call(context, self, var, value);
  1799.         elementAsgnSite.call(context, self, receiver, result);

  1801.         return result;
  1802.     }
  1803.     
  1804.     public static IRubyObject opElementAsgnWithMethod(ThreadContext context, IRubyObject self, IRubyObject receiver, IRubyObject arg, IRubyObject value, CallSite elementSite, CallSite opSite, CallSite elementAsgnSite) {
  1805.         IRubyObject var = elementSite.call(context, self, receiver, arg);
  1806.         IRubyObject result = opSite.call(context, self, var, value);
  1807.         elementAsgnSite.call(context, self, receiver, arg, result);

  1809.         return result;
  1810.     }
  1811.     
  1812.     public static IRubyObject opElementAsgnWithMethod(ThreadContext context, IRubyObject self, IRubyObject receiver, IRubyObject arg1, IRubyObject arg2, IRubyObject value, CallSite elementSite, CallSite opSite, CallSite elementAsgnSite) {
  1813.         IRubyObject var = elementSite.call(context, self, receiver, arg1, arg2);
  1814.         IRubyObject result = opSite.call(context, self, var, value);
  1815.         elementAsgnSite.call(context, self, receiver, arg1, arg2, result);

  1817.         return result;
  1818.     }
  1819.     
  1820.     public static IRubyObject opElementAsgnWithMethod(ThreadContext context, IRubyObject self, IRubyObject receiver, IRubyObject arg1, IRubyObject arg2, IRubyObject arg3, IRubyObject value, CallSite elementSite, CallSite opSite, CallSite elementAsgnSite) {
  1821.         IRubyObject var = elementSite.call(context, self, receiver, arg1, arg2, arg3);
  1822.         IRubyObject result = opSite.call(context, self, var, value);
  1823.         elementAsgnSite.call(context, self, receiver, new IRubyObject[] {arg1, arg2, arg3, result});

  1825.         return result;
  1826.     }
  1827.     
  1828.     public static IRubyObject opElementAsgnWithMethod(ThreadContext context, IRubyObject self, IRubyObject receiver, IRubyObject[] args, IRubyObject value, CallSite elementSite, CallSite opSite, CallSite elementAsgnSite) {
  1829.         IRubyObject var = elementSite.call(context, self, receiver);
  1830.         IRubyObject result = opSite.call(context, self, var, value);
  1831.         elementAsgnSite.call(context, self, receiver, appendToObjectArray(args, result));

  1833.         return result;
  1834.     }

  1836.     
  1837.     public static IRubyObject opElementAsgnWithOrPartTwoOneArg(ThreadContext context, IRubyObject self, IRubyObject receiver, IRubyObject arg, IRubyObject value, CallSite asetSite) {
  1838.         asetSite.call(context, self, receiver, arg, value);
  1839.         return value;
  1840.     }
  1841.     
  1842.     public static IRubyObject opElementAsgnWithOrPartTwoTwoArgs(ThreadContext context, IRubyObject self, IRubyObject receiver, IRubyObject[] args, IRubyObject value, CallSite asetSite) {
  1843.         asetSite.call(context, self, receiver, args[0], args[1], value);
  1844.         return value;
  1845.     }
  1846.     
  1847.     public static IRubyObject opElementAsgnWithOrPartTwoThreeArgs(ThreadContext context, IRubyObject self, IRubyObject receiver, IRubyObject[] args, IRubyObject value, CallSite asetSite) {
  1848.         asetSite.call(context, self, receiver, new IRubyObject[] {args[0], args[1], args[2], value});
  1849.         return value;
  1850.     }
  1851.     
  1852.     public static IRubyObject opElementAsgnWithOrPartTwoNArgs(ThreadContext context, IRubyObject self, IRubyObject receiver, IRubyObject[] args, IRubyObject value, CallSite asetSite) {
  1853.         IRubyObject[] newArgs = new IRubyObject[args.length + 1];
  1854.         System.arraycopy(args, 0, newArgs, 0, args.length);
  1855.         newArgs[args.length] = value;
  1856.         asetSite.call(context, self, receiver, newArgs);
  1857.         return value;
  1858.     }

  1860.     public static RubyArray arrayValue(IRubyObject value) {
  1861.         Ruby runtime = value.getRuntime();
  1862.         return arrayValue(runtime.getCurrentContext(), runtime, value);
  1863.     }
  1864.     
  1865.     public static RubyArray arrayValue(ThreadContext context, Ruby runtime, IRubyObject value) {
  1866.         IRubyObject tmp = value.checkArrayType();

  1868.         if (tmp.isNil()) {
  1869.             // Object#to_a is obsolete.  We match Ruby's hack until to_a goes away.  Then we can
  1870.             // remove this hack too.

  1872.             if (value.respondsTo("to_a") && value.getMetaClass().searchMethod("to_a").getImplementationClass() != runtime.getKernel()) {
  1873.                 IRubyObject avalue = value.callMethod(context, "to_a");
  1874.                 if (!(avalue instanceof RubyArray)) {
  1875.                     if (avalue.isNil()) {
  1876.                         return runtime.newArray(value);
  1877.                     } else {
  1878.                         throw runtime.newTypeError("`to_a' did not return Array");
  1879.                     }
  1880.                 }
  1881.                 return (RubyArray)avalue;
  1882.             } else {
  1883.                 return runtime.newArray(value);
  1884.             }
  1885.         }
  1886.         RubyArray arr = (RubyArray) tmp;
  1887.         
  1888.         return arr.aryDup();
  1889.     }

  1891.     public static RubyArray asArray18(ThreadContext context, IRubyObject value) {
  1892.         Ruby runtime = context.runtime;
  1893.         IRubyObject tmp = value.checkArrayType();

  1895.         if (tmp.isNil()) {
  1896.             // Object#to_a is obsolete.  We match Ruby's hack until to_a goes away.  Then we can
  1897.             // remove this hack too.

  1899.             if (value.respondsTo("to_a") && value.getMetaClass().searchMethod("to_a").getImplementationClass() != runtime.getKernel()) {
  1900.                 IRubyObject avalue = value.callMethod(context, "to_a");
  1901.                 if (!(avalue instanceof RubyArray)) {
  1902.                     if (avalue.isNil()) {
  1903.                         return runtime.newArray(value);
  1904.                     } else {
  1905.                         throw runtime.newTypeError("`to_a' did not return Array");
  1906.                     }
  1907.                 }
  1908.                 return (RubyArray)avalue;
  1909.             } else {
  1910.                 return runtime.newArray(value);
  1911.             }
  1912.         }
  1913.         
  1914.         return (RubyArray) tmp;
  1915.     }
  1916.     
  1917.     // mri: rb_Array
  1918.     // FIXME: Replace arrayValue/asArray18 with this on 9k (currently dead -- respond_to? logic broken further down the line -- fix that first)
  1919.     public static RubyArray asArray(ThreadContext context, IRubyObject value) {
  1920.         return TypeConverter.rb_Array(context, value);
  1921.     }
  1922.     
  1923.     public static IRubyObject aryToAry(IRubyObject value) {
  1924.         if (value instanceof RubyArray) return value;

  1926.         if (value.respondsTo("to_ary")) {
  1927.             return TypeConverter.convertToType(value, value.getRuntime().getArray(), "to_ary", false);
  1928.         }

  1930.         return value.getRuntime().newArray(value);
  1931.     }

  1933.     public static IRubyObject aValueSplat(IRubyObject value) {
  1934.         if (!(value instanceof RubyArray) || ((RubyArray) value).length().getLongValue() == 0) {
  1935.             return value.getRuntime().getNil();
  1936.         }

  1938.         RubyArray array = (RubyArray) value;

  1940.         return array.getLength() == 1 ? array.first() : array;
  1941.     }

  1943.     public static IRubyObject aValueSplat19(IRubyObject value) {
  1944.         if (!(value instanceof RubyArray)) {
  1945.             return value.getRuntime().getNil();
  1946.         }

  1948.         return (RubyArray) value;
  1949.     }

  1951.     public static RubyArray splatValue(IRubyObject value) {
  1952.         if (value.isNil()) {
  1953.             return value.getRuntime().newArray(value);
  1954.         }

  1956.         return arrayValue(value);
  1957.     }

  1959.     public static RubyArray splatValue19(IRubyObject value) {
  1960.         if (value.isNil()) {
  1961.             return value.getRuntime().newEmptyArray();
  1962.         }

  1964.         return arrayValue(value);
  1965.     }
  1966.     
  1967.     public static IRubyObject unsplatValue19(IRubyObject argsResult) {
  1968.         if (argsResult instanceof RubyArray) {
  1969.             RubyArray array = (RubyArray) argsResult;
  1970.                     
  1971.             if (array.size() == 1) {
  1972.                 IRubyObject newResult = array.eltInternal(0);
  1973.                 if (!((newResult instanceof RubyArray) && ((RubyArray) newResult).size() == 0)) {
  1974.                     argsResult = newResult;
  1975.                 }
  1976.             }
  1977.         }        
  1978.         return argsResult;
  1979.     }

  1981.     public static IRubyObject unsplatValue19IfArityOne(IRubyObject argsResult, Block block) {
  1982.         if (block.isGiven() && block.arity().getValue() > 1) argsResult = Helpers.unsplatValue19(argsResult);
  1983.         return argsResult;
  1984.     }
  1985.         
  1986.     public static IRubyObject[] splatToArguments(IRubyObject value) {
  1987.         Ruby runtime = value.getRuntime();
  1988.         
  1989.         if (value.isNil()) {
  1990.             return runtime.getSingleNilArray();
  1991.         }
  1992.         
  1993.         return splatToArgumentsCommon(runtime, value);
  1994.     }
  1995.     
  1996.     public static IRubyObject[] splatToArguments19(IRubyObject value) {
  1997.         Ruby runtime = value.getRuntime();
  1998.         
  1999.         if (value.isNil()) {
  2000.             return IRubyObject.NULL_ARRAY;
  2001.         }
  2002.         
  2003.         return splatToArgumentsCommon(runtime, value);
  2004.     }
  2005.     
  2006.     private static IRubyObject[] splatToArgumentsCommon(Ruby runtime, IRubyObject value) {
  2007.         
  2008.         if (value.isNil()) {
  2009.             return runtime.getSingleNilArray();
  2010.         }
  2011.         
  2012.         IRubyObject tmp = value.checkArrayType();

  2014.         if (tmp.isNil()) {
  2015.             return convertSplatToJavaArray(runtime, value);
  2016.         }
  2017.         return ((RubyArray)tmp).toJavaArrayMaybeUnsafe();
  2018.     }
  2019.     
  2020.     private static IRubyObject[] convertSplatToJavaArray(Ruby runtime, IRubyObject value) {
  2021.         // Object#to_a is obsolete.  We match Ruby's hack until to_a goes away.  Then we can
  2022.         // remove this hack too.

  2024.         RubyClass metaClass = value.getMetaClass();
  2025.         DynamicMethod method = metaClass.searchMethod("to_a");
  2026.         if (method.isUndefined() || method.isImplementedBy(runtime.getKernel())) {
  2027.             return new IRubyObject[] {value};
  2028.         }

  2030.         IRubyObject avalue = method.call(runtime.getCurrentContext(), value, metaClass, "to_a");
  2031.         if (!(avalue instanceof RubyArray)) {
  2032.             if (avalue.isNil()) {
  2033.                 return new IRubyObject[] {value};
  2034.             } else {
  2035.                 throw runtime.newTypeError("`to_a' did not return Array");
  2036.             }
  2037.         }
  2038.         return ((RubyArray)avalue).toJavaArray();
  2039.     }
  2040.     
  2041.     public static IRubyObject[] argsCatToArguments(IRubyObject[] args, IRubyObject cat) {
  2042.         IRubyObject[] ary = splatToArguments(cat);
  2043.         return argsCatToArgumentsCommon(args, ary);
  2044.     }
  2045.     
  2046.     public static IRubyObject[] argsCatToArguments19(IRubyObject[] args, IRubyObject cat) {
  2047.         IRubyObject[] ary = splatToArguments19(cat);
  2048.         return argsCatToArgumentsCommon(args, ary);
  2049.     }
  2050.     
  2051.     private static IRubyObject[] argsCatToArgumentsCommon(IRubyObject[] args, IRubyObject[] ary) {
  2052.         if (ary.length > 0) {
  2053.             IRubyObject[] newArgs = new IRubyObject[args.length + ary.length];
  2054.             System.arraycopy(args, 0, newArgs, 0, args.length);
  2055.             System.arraycopy(ary, 0, newArgs, args.length, ary.length);
  2056.             args = newArgs;
  2057.         }
  2058.         
  2059.         return args;
  2060.     }

  2062.     public static RubySymbol addInstanceMethod(RubyModule containingClass, String name, DynamicMethod method, Visibility visibility, ThreadContext context, Ruby runtime) {
  2063.         containingClass.addMethod(name, method);

  2065.         RubySymbol sym = runtime.fastNewSymbol(name);
  2066.         if (visibility == Visibility.MODULE_FUNCTION) {
  2067.             addModuleMethod(containingClass, name, method, context, sym);
  2068.         }

  2070.         callNormalMethodHook(containingClass, context, sym);

  2072.         return sym;
  2073.     }

  2075.     private static void addModuleMethod(RubyModule containingClass, String name, DynamicMethod method, ThreadContext context, RubySymbol sym) {
  2076.         containingClass.getSingletonClass().addMethod(name, new WrapperMethod(containingClass.getSingletonClass(), method, Visibility.PUBLIC));
  2077.         containingClass.callMethod(context, "singleton_method_added", sym);
  2078.     }

  2080.     private static void callNormalMethodHook(RubyModule containingClass, ThreadContext context, RubySymbol name) {
  2081.         // 'class << state.self' and 'class << obj' uses defn as opposed to defs
  2082.         if (containingClass.isSingleton()) {
  2083.             callSingletonMethodHook(((MetaClass) containingClass).getAttached(), context, name);
  2084.         } else {
  2085.             containingClass.callMethod(context, "method_added", name);
  2086.         }
  2087.     }

  2089.     private static void callSingletonMethodHook(IRubyObject receiver, ThreadContext context, RubySymbol name) {
  2090.         receiver.callMethod(context, "singleton_method_added", name);
  2091.     }

  2093.     private static DynamicMethod constructNormalMethod(
  2094.             MethodFactory factory,
  2095.             String javaName,
  2096.             String name,
  2097.             RubyModule containingClass,
  2098.             ISourcePosition position,
  2099.             int arity,
  2100.             StaticScope scope,
  2101.             Visibility visibility,
  2102.             Object scriptObject,
  2103.             CallConfiguration callConfig,
  2104.             String parameterDesc,
  2105.             MethodNodes methodNodes) {
  2106.         
  2107.         DynamicMethod method;
  2108.         final Ruby runtime = containingClass.getRuntime();

  2110.         if (name.equals("initialize") || name.equals("initialize_copy") || name.equals("initialize_clone") || name.equals("initialize_dup") || name.equals("respond_to_missing?") || visibility == Visibility.MODULE_FUNCTION) {
  2111.             visibility = Visibility.PRIVATE;
  2112.         }
  2113.         
  2114.         if (RubyInstanceConfig.LAZYHANDLES_COMPILE) {
  2115.             method = factory.getCompiledMethodLazily(
  2116.                     containingClass,
  2117.                     name,
  2118.                     javaName,
  2119.                     Arity.createArity(arity),
  2120.                     visibility,
  2121.                     scope,
  2122.                     scriptObject,
  2123.                     callConfig,
  2124.                     position,
  2125.                     parameterDesc,
  2126.                     methodNodes);
  2127.         } else {
  2128.             method = factory.getCompiledMethod(
  2129.                     containingClass,
  2130.                     name,
  2131.                     javaName,
  2132.                     Arity.createArity(arity),
  2133.                     visibility,
  2134.                     scope,
  2135.                     scriptObject,
  2136.                     callConfig,
  2137.                     position,
  2138.                     parameterDesc,
  2139.                     methodNodes);
  2140.         }

  2142.         return method;
  2143.     }

  2145.     private static DynamicMethod constructSingletonMethod(
  2146.             MethodFactory factory,
  2147.             String rubyName,
  2148.             String javaName,
  2149.             RubyClass rubyClass,
  2150.             ISourcePosition position,
  2151.             int arity,
  2152.             StaticScope scope,
  2153.             Object scriptObject,
  2154.             CallConfiguration callConfig,
  2155.             String parameterDesc,
  2156.             MethodNodes methodNodes) {
  2157.         
  2158.         if (RubyInstanceConfig.LAZYHANDLES_COMPILE) {
  2159.             return factory.getCompiledMethodLazily(
  2160.                     rubyClass,
  2161.                     rubyName,
  2162.                     javaName,
  2163.                     Arity.createArity(arity),
  2164.                     Visibility.PUBLIC,
  2165.                     scope,
  2166.                     scriptObject,
  2167.                     callConfig,
  2168.                     position,
  2169.                     parameterDesc,
  2170.                     methodNodes);
  2171.         } else {
  2172.             return factory.getCompiledMethod(
  2173.                     rubyClass,
  2174.                     rubyName,
  2175.                     javaName,
  2176.                     Arity.createArity(arity),
  2177.                     Visibility.PUBLIC,
  2178.                     scope,
  2179.                     scriptObject,
  2180.                     callConfig,
  2181.                     position,
  2182.                     parameterDesc,
  2183.                     methodNodes);
  2184.         }
  2185.     }

  2187.     public static String encodeScope(StaticScope scope) {
  2188.         StringBuilder namesBuilder = new StringBuilder(scope.getType().name());

  2190.         namesBuilder.append(',');

  2192.         boolean first = true;
  2193.         for (String name : scope.getVariables()) {
  2194.             if (!first) namesBuilder.append(';');
  2195.             first = false;
  2196.             namesBuilder.append(name);
  2197.         }
  2198.         namesBuilder
  2199.                 .append(',')
  2200.                 .append(scope.getRequiredArgs())
  2201.                 .append(',')
  2202.                 .append(scope.getOptionalArgs())
  2203.                 .append(',')
  2204.                 .append(scope.getRestArg())
  2205.                 .append(',')
  2206.                 .append(scope.getScopeType());

  2208.         return namesBuilder.toString();
  2209.     }

  2211.     public static StaticScope decodeScope(ThreadContext context, StaticScope parent, String scopeString) {
  2212.         String[][] decodedScope = decodeScopeDescriptor(scopeString);
  2213.         StaticScope scope = null;
  2214.         switch (StaticScope.Type.valueOf(decodedScope[0][0])) {
  2215.             case BLOCK:
  2216.                 scope = context.runtime.getStaticScopeFactory().newBlockScope(parent, decodedScope[1]);
  2217.                 break;
  2218.             case EVAL:
  2219.                 scope = context.runtime.getStaticScopeFactory().newEvalScope(parent, decodedScope[1]);
  2220.                 break;
  2221.             case LOCAL:
  2222.                 scope = context.runtime.getStaticScopeFactory().newLocalScope(parent, decodedScope[1]);
  2223.                 break;
  2224.         }
  2225.         setAritiesFromDecodedScope(scope, decodedScope[0]);
  2226.         scope.setScopeType(IRScopeType.valueOf(decodedScope[0][5]));
  2227.         return scope;
  2228.     }

  2230.     private static String[][] decodeScopeDescriptor(String scopeString) {
  2231.         String[] scopeElements = scopeString.split(",");
  2232.         String[] scopeNames = scopeElements[1].length() == 0 ? new String[0] : getScopeNames(scopeElements[1]);
  2233.         return new String[][] {scopeElements, scopeNames};
  2234.     }

  2236.     private static void setAritiesFromDecodedScope(StaticScope scope, String[] scopeElements) {
  2237.         scope.setArities(Integer.parseInt(scopeElements[2]), Integer.parseInt(scopeElements[3]), Integer.parseInt(scopeElements[4]));
  2238.     }

  2240.     public static StaticScope decodeScopeAndDetermineModule(ThreadContext context, StaticScope parent, String scopeString) {
  2241.         StaticScope scope = decodeScope(context, parent, scopeString);
  2242.         scope.determineModule();

  2244.         return scope;
  2245.     }

  2247.     public static Visibility performNormalMethodChecksAndDetermineVisibility(Ruby runtime, RubyModule clazz, String name, Visibility visibility) throws RaiseException {
  2248.         if (clazz == runtime.getDummy()) {
  2249.             throw runtime.newTypeError("no class/module to add method");
  2250.         }

  2252.         if (clazz == runtime.getObject() && "initialize".equals(name)) {
  2253.             runtime.getWarnings().warn(ID.REDEFINING_DANGEROUS, "redefining Object#initialize may cause infinite loop");
  2254.         }

  2256.         if ("__id__".equals(name) || "__send__".equals(name)) {
  2257.             runtime.getWarnings().warn(ID.REDEFINING_DANGEROUS, "redefining `" + name + "' may cause serious problem");
  2258.         }

  2260.         if ("initialize".equals(name) || "initialize_copy".equals(name) || name.equals("initialize_dup") || name.equals("initialize_clone") || name.equals("respond_to_missing?") || visibility == Visibility.MODULE_FUNCTION) {
  2261.             visibility = Visibility.PRIVATE;
  2262.         }

  2264.         return visibility;
  2265.     }

  2267.     public static RubyClass performSingletonMethodChecks(Ruby runtime, IRubyObject receiver, String name) throws RaiseException {
  2268.         if (receiver instanceof RubyFixnum || receiver instanceof RubySymbol) {
  2269.             throw runtime.newTypeError("can't define singleton method \"" + name + "\" for " + receiver.getMetaClass().getBaseName());
  2270.         }

  2272.         if (receiver.isFrozen()) {
  2273.             throw runtime.newFrozenError("object");
  2274.         }
  2275.         
  2276.         RubyClass rubyClass = receiver.getSingletonClass();
  2277.         
  2278.         return rubyClass;
  2279.     }
  2280.     
  2281.     public static IRubyObject arrayEntryOrNil(RubyArray array, int index) {
  2282.         if (index < array.getLength()) {
  2283.             return array.eltInternal(index);
  2284.         } else {
  2285.             return array.getRuntime().getNil();
  2286.         }
  2287.     }

  2289.     public static IRubyObject arrayEntryOrNilZero(RubyArray array) {
  2290.         if (0 < array.getLength()) {
  2291.             return array.eltInternal(0);
  2292.         } else {
  2293.             return array.getRuntime().getNil();
  2294.         }
  2295.     }

  2297.     public static IRubyObject arrayEntryOrNilOne(RubyArray array) {
  2298.         if (1 < array.getLength()) {
  2299.             return array.eltInternal(1);
  2300.         } else {
  2301.             return array.getRuntime().getNil();
  2302.         }
  2303.     }

  2305.     public static IRubyObject arrayEntryOrNilTwo(RubyArray array) {
  2306.         if (2 < array.getLength()) {
  2307.             return array.eltInternal(2);
  2308.         } else {
  2309.             return array.getRuntime().getNil();
  2310.         }
  2311.     }

  2313.     public static IRubyObject arrayPostOrNil(RubyArray array, int pre, int post, int index) {
  2314.         if (pre + post < array.getLength()) {
  2315.             return array.eltInternal(array.getLength() - post + index);
  2316.         } else if (pre + index < array.getLength()) {
  2317.             return array.eltInternal(pre + index);
  2318.         } else {
  2319.             return array.getRuntime().getNil();
  2320.         }
  2321.     }

  2323.     public static IRubyObject arrayPostOrNilZero(RubyArray array, int pre, int post) {
  2324.         if (pre + post < array.getLength()) {
  2325.             return array.eltInternal(array.getLength() - post + 0);
  2326.         } else if (pre + 0 < array.getLength()) {
  2327.             return array.eltInternal(pre + 0);
  2328.         } else {
  2329.             return array.getRuntime().getNil();
  2330.         }
  2331.     }

  2333.     public static IRubyObject arrayPostOrNilOne(RubyArray array, int pre, int post) {
  2334.         if (pre + post < array.getLength()) {
  2335.             return array.eltInternal(array.getLength() - post + 1);
  2336.         } else if (pre + 1 < array.getLength()) {
  2337.             return array.eltInternal(pre + 1);
  2338.         } else {
  2339.             return array.getRuntime().getNil();
  2340.         }
  2341.     }

  2343.     public static IRubyObject arrayPostOrNilTwo(RubyArray array, int pre, int post) {
  2344.         if (pre + post < array.getLength()) {
  2345.             return array.eltInternal(array.getLength() - post + 2);
  2346.         } else if (pre + 2 < array.getLength()) {
  2347.             return array.eltInternal(pre + 2);
  2348.         } else {
  2349.             return array.getRuntime().getNil();
  2350.         }
  2351.     }
  2352.     
  2353.     public static RubyArray subarrayOrEmpty(RubyArray array, Ruby runtime, int index) {
  2354.         if (index < array.getLength()) {
  2355.             return createSubarray(array, index);
  2356.         } else {
  2357.             return RubyArray.newEmptyArray(runtime);
  2358.         }
  2359.     }

  2361.     public static RubyArray subarrayOrEmpty(RubyArray array, Ruby runtime, int index, int post) {
  2362.         if (index + post < array.getLength()) {
  2363.             return createSubarray(array, index, post);
  2364.         } else {
  2365.             return RubyArray.newEmptyArray(runtime);
  2366.         }
  2367.     }
  2368.     
  2369.     public static RubyModule checkIsModule(IRubyObject maybeModule) {
  2370.         if (maybeModule instanceof RubyModule) return (RubyModule)maybeModule;
  2371.         
  2372.         throw maybeModule.getRuntime().newTypeError(maybeModule + " is not a class/module");
  2373.     }
  2374.     
  2375.     public static IRubyObject getGlobalVariable(Ruby runtime, String name) {
  2376.         return runtime.getGlobalVariables().get(name);
  2377.     }
  2378.     
  2379.     public static IRubyObject setGlobalVariable(IRubyObject value, Ruby runtime, String name) {
  2380.         return runtime.getGlobalVariables().set(name, value);
  2381.     }

  2383.     public static IRubyObject getInstanceVariable(IRubyObject self, Ruby runtime, String internedName) {
  2384.         IRubyObject result = self.getInstanceVariables().getInstanceVariable(internedName);
  2385.         if (result != null) return result;
  2386.         if (runtime.isVerbose()) warnAboutUninitializedIvar(runtime, internedName);
  2387.         return runtime.getNil();
  2388.     }

  2390.     public static IRubyObject getInstanceVariableNoWarn(IRubyObject self, ThreadContext context, String internedName) {
  2391.         IRubyObject result = self.getInstanceVariables().getInstanceVariable(internedName);
  2392.         if (result != null) return result;
  2393.         return context.nil;
  2394.     }

  2396.     private static void warnAboutUninitializedIvar(Ruby runtime, String internedName) {
  2397.         runtime.getWarnings().warning(ID.IVAR_NOT_INITIALIZED, "instance variable " + internedName + " not initialized");
  2398.     }

  2400.     public static IRubyObject setInstanceVariable(IRubyObject value, IRubyObject self, String name) {
  2401.         return self.getInstanceVariables().setInstanceVariable(name, value);
  2402.     }

  2404.     public static RubyProc newLiteralLambda(ThreadContext context, Block block, IRubyObject self) {
  2405.         return RubyProc.newProc(context.runtime, block, Block.Type.LAMBDA);
  2406.     }

  2408.     public static void fillNil(IRubyObject[]arr, int from, int to, Ruby runtime) {
  2409.         if (arr.length == 0) return;
  2410.         IRubyObject nils[] = runtime.getNilPrefilledArray();
  2411.         int i;

  2413.         for (i = from; i + Ruby.NIL_PREFILLED_ARRAY_SIZE < to; i += Ruby.NIL_PREFILLED_ARRAY_SIZE) {
  2414.             System.arraycopy(nils, 0, arr, i, Ruby.NIL_PREFILLED_ARRAY_SIZE);
  2415.         }
  2416.         System.arraycopy(nils, 0, arr, i, to - i);
  2417.     }

  2419.     public static void fillNil(IRubyObject[]arr, Ruby runtime) {
  2420.         if (arr.length == 0) return;
  2421.         fillNil(arr, 0, arr.length, runtime);
  2422.     }

  2424.     public static boolean isFastSwitchableString(IRubyObject str) {
  2425.         return str instanceof RubyString;
  2426.     }

  2428.     public static boolean isFastSwitchableSingleCharString(IRubyObject str) {
  2429.         return str instanceof RubyString && ((RubyString)str).getByteList().length() == 1;
  2430.     }

  2432.     public static int getFastSwitchString(IRubyObject str) {
  2433.         ByteList byteList = ((RubyString)str).getByteList();
  2434.         return byteList.hashCode();
  2435.     }

  2437.     public static int getFastSwitchSingleCharString(IRubyObject str) {
  2438.         ByteList byteList = ((RubyString)str).getByteList();
  2439.         return byteList.get(0);
  2440.     }

  2442.     public static boolean isFastSwitchableSymbol(IRubyObject sym) {
  2443.         return sym instanceof RubySymbol;
  2444.     }

  2446.     public static boolean isFastSwitchableSingleCharSymbol(IRubyObject sym) {
  2447.         return sym instanceof RubySymbol && ((RubySymbol)sym).asJavaString().length() == 1;
  2448.     }

  2450.     public static int getFastSwitchSymbol(IRubyObject sym) {
  2451.         String str = ((RubySymbol)sym).asJavaString();
  2452.         return str.hashCode();
  2453.     }

  2455.     public static int getFastSwitchSingleCharSymbol(IRubyObject sym) {
  2456.         String str = ((RubySymbol)sym).asJavaString();
  2457.         return (int)str.charAt(0);
  2458.     }

  2460.     public static Block getBlock(ThreadContext context, IRubyObject self, Node node) {
  2461.         throw new RuntimeException("Should not be called");
  2462.     }

  2464.     public static Block getBlock(Ruby runtime, ThreadContext context, IRubyObject self, Node node, Block aBlock) {
  2465.         throw new RuntimeException("Should not be called");
  2466.     }

  2468.     /**
  2469.      * Equivalent to rb_equal in MRI
  2470.      *
  2471.      * @param context
  2472.      * @param a
  2473.      * @param b
  2474.      * @return
  2475.      */
  2476.     public static RubyBoolean rbEqual(ThreadContext context, IRubyObject a, IRubyObject b) {
  2477.         Ruby runtime = context.runtime;
  2478.         if (a == b) return runtime.getTrue();
  2479.         IRubyObject res = invokedynamic(context, a, OP_EQUAL, b);
  2480.         return runtime.newBoolean(res.isTrue());
  2481.     }

  2483.     /**
  2484.      * Equivalent to rb_eql in MRI
  2485.      *
  2486.      * @param context
  2487.      * @param a
  2488.      * @param b
  2489.      * @return
  2490.      */
  2491.     public static RubyBoolean rbEql(ThreadContext context, IRubyObject a, IRubyObject b) {
  2492.         Ruby runtime = context.runtime;
  2493.         if (a == b) return runtime.getTrue();
  2494.         IRubyObject res = invokedynamic(context, a, EQL, b);
  2495.         return runtime.newBoolean(res.isTrue());
  2496.     }

  2498.     /**
  2499.      * Used by the compiler to simplify arg checking in variable-arity paths
  2500.      *
  2501.      * @param context thread context
  2502.      * @param args arguments array
  2503.      * @param min minimum required
  2504.      * @param max maximum allowed
  2505.      */
  2506.     public static void checkArgumentCount(ThreadContext context, IRubyObject[] args, int min, int max) {
  2507.         checkArgumentCount(context, args.length, min, max);
  2508.     }

  2510.     /**
  2511.      * Used by the compiler to simplify arg checking in variable-arity paths
  2512.      *
  2513.      * @param context thread context
  2514.      * @param args arguments array
  2515.      * @param req required number
  2516.      */
  2517.     public static void checkArgumentCount(ThreadContext context, IRubyObject[] args, int req) {
  2518.         checkArgumentCount(context, args.length, req, req);
  2519.     }
  2520.     
  2521.     public static void checkArgumentCount(ThreadContext context, int length, int min, int max) {
  2522.         int expected = 0;
  2523.         if (length < min) {
  2524.             expected = min;
  2525.         } else if (max > -1 && length > max) {
  2526.             expected = max;
  2527.         } else {
  2528.             return;
  2529.         }
  2530.         throw context.runtime.newArgumentError(length, expected);
  2531.     }

  2533.     public static boolean isModuleAndHasConstant(IRubyObject left, String name) {
  2534.         return left instanceof RubyModule && ((RubyModule) left).getConstantFromNoConstMissing(name, false) != null;
  2535.     }

  2537.     public static RubyString getDefinedConstantOrBoundMethod(IRubyObject left, String name) {
  2538.         if (isModuleAndHasConstant(left, name)) return left.getRuntime().getDefinedMessage(DefinedMessage.CONSTANT);
  2539.         if (left.getMetaClass().isMethodBound(name, true)) left.getRuntime().getDefinedMessage(DefinedMessage.METHOD);
  2540.         return null;
  2541.     }

  2543.     public static RubyModule getSuperClassForDefined(Ruby runtime, RubyModule klazz) {
  2544.         RubyModule superklazz = klazz.getSuperClass();

  2546.         if (superklazz == null && klazz.isModule()) superklazz = runtime.getObject();

  2548.         return superklazz;
  2549.     }

  2551.     public static boolean isGenerationEqual(IRubyObject object, int generation) {
  2552.         RubyClass metaClass;
  2553.         if (object instanceof RubyBasicObject) {
  2554.             metaClass = ((RubyBasicObject)object).getMetaClass();
  2555.         } else {
  2556.             metaClass = object.getMetaClass();
  2557.         }
  2558.         return metaClass.getGeneration() == generation;
  2559.     }

  2561.     public static String[] getScopeNames(String scopeNames) {
  2562.         StringTokenizer toker = new StringTokenizer(scopeNames, ";");
  2563.         ArrayList list = new ArrayList(10);
  2564.         while (toker.hasMoreTokens()) {
  2565.             list.add(toker.nextToken().intern());
  2566.         }
  2567.         return (String[])list.toArray(new String[list.size()]);
  2568.     }

  2570.     public static IRubyObject[] arraySlice1N(IRubyObject arrayish) {
  2571.         arrayish = aryToAry(arrayish);
  2572.         RubyArray arrayish2 = ensureMultipleAssignableRubyArray(arrayish, arrayish.getRuntime(), true);
  2573.         return new IRubyObject[] {arrayEntryOrNilZero(arrayish2), subarrayOrEmpty(arrayish2, arrayish2.getRuntime(), 1)};
  2574.     }

  2576.     public static IRubyObject arraySlice1(IRubyObject arrayish) {
  2577.         arrayish = aryToAry(arrayish);
  2578.         RubyArray arrayish2 = ensureMultipleAssignableRubyArray(arrayish, arrayish.getRuntime(), true);
  2579.         return arrayEntryOrNilZero(arrayish2);
  2580.     }

  2582.     public static RubyClass metaclass(IRubyObject object) {
  2583.         return object instanceof RubyBasicObject ?
  2584.             ((RubyBasicObject)object).getMetaClass() :
  2585.             object.getMetaClass();
  2586.     }

  2588.     public static String rawBytesToString(byte[] bytes) {
  2589.         // stuff bytes into chars
  2590.         char[] chars = new char[bytes.length];
  2591.         for (int i = 0; i < bytes.length; i++) chars[i] = (char)bytes[i];
  2592.         return new String(chars);
  2593.     }

  2595.     public static byte[] stringToRawBytes(String string) {
  2596.         char[] chars = string.toCharArray();
  2597.         byte[] bytes = new byte[chars.length];
  2598.         for (int i = 0; i < chars.length; i++) bytes[i] = (byte)chars[i];
  2599.         return bytes;
  2600.     }

  2602.     public static String encodeCaptureOffsets(int[] scopeOffsets) {
  2603.         char[] encoded = new char[scopeOffsets.length * 2];
  2604.         for (int i = 0; i < scopeOffsets.length; i++) {
  2605.             int offDepth = scopeOffsets[i];
  2606.             char off = (char)(offDepth & 0xFFFF);
  2607.             char depth = (char)(offDepth >> 16);
  2608.             encoded[2 * i] = off;
  2609.             encoded[2 * i + 1] = depth;
  2610.         }
  2611.         return new String(encoded);
  2612.     }

  2614.     public static int[] decodeCaptureOffsets(String encoded) {
  2615.         char[] chars = encoded.toCharArray();
  2616.         int[] scopeOffsets = new int[chars.length / 2];
  2617.         for (int i = 0; i < scopeOffsets.length; i++) {
  2618.             char off = chars[2 * i];
  2619.             char depth = chars[2 * i + 1];
  2620.             scopeOffsets[i] = (((int)depth) << 16) | (int)off;
  2621.         }
  2622.         return scopeOffsets;
  2623.     }

  2625.     public static IRubyObject match2AndUpdateScope(IRubyObject receiver, ThreadContext context, IRubyObject value, String scopeOffsets) {
  2626.         IRubyObject match = ((RubyRegexp)receiver).op_match(context, value);
  2627.         updateScopeWithCaptures(context, decodeCaptureOffsets(scopeOffsets), match);
  2628.         return match;
  2629.     }

  2631.     public static IRubyObject match2AndUpdateScope19(IRubyObject receiver, ThreadContext context, IRubyObject value, String scopeOffsets) {
  2632.         IRubyObject match = ((RubyRegexp)receiver).op_match19(context, value);
  2633.         updateScopeWithCaptures(context, decodeCaptureOffsets(scopeOffsets), match);
  2634.         return match;
  2635.     }

  2637.     public static void updateScopeWithCaptures(ThreadContext context, int[] scopeOffsets, IRubyObject result) {
  2638.         Ruby runtime = context.runtime;
  2639.         if (result.isNil()) { // match2 directly calls match so we know we can count on result
  2640.             IRubyObject nil = runtime.getNil();

  2642.             for (int i = 0; i < scopeOffsets.length; i++) {
  2643.                 // SSS FIXME: This is not doing the offset/depth extraction as in the else case
  2644.                 context.getCurrentScope().setValue(nil, scopeOffsets[i], 0);
  2645.             }
  2646.         } else {
  2647.             RubyMatchData matchData = (RubyMatchData)context.getBackRef();
  2648.             // FIXME: Mass assignment is possible since we know they are all locals in the same
  2649.             //   scope that are also contiguous
  2650.             IRubyObject[] namedValues = matchData.getNamedBackrefValues(runtime);

  2652.             for (int i = 0; i < scopeOffsets.length; i++) {
  2653.                 context.getCurrentScope().setValue(namedValues[i], scopeOffsets[i] & 0xffff, scopeOffsets[i] >> 16);
  2654.             }
  2655.         }
  2656.     }

  2658.     public static RubyArray argsPush(RubyArray first, IRubyObject second) {
  2659.         return ((RubyArray)first.dup()).append(second);
  2660.     }

  2662.     public static RubyArray argsCat(IRubyObject first, IRubyObject second) {
  2663.         Ruby runtime = first.getRuntime();
  2664.         IRubyObject secondArgs;
  2665.         secondArgs = Helpers.splatValue19(second);

  2667.         return ((RubyArray) Helpers.ensureRubyArray(runtime, first).dup()).concat(secondArgs);
  2668.     }

  2670.     public static String encodeParameterList(ArgsNode argsNode) {
  2671.         StringBuilder builder = new StringBuilder();
  2672.         
  2673.         boolean added = false;
  2674.         if (argsNode.getPre() != null) {
  2675.             for (Node preNode : argsNode.getPre().childNodes()) {
  2676.                 if (added) builder.append(';');
  2677.                 added = true;
  2678.                 if (preNode instanceof MultipleAsgn19Node) {
  2679.                     builder.append("nil");
  2680.                 } else {
  2681.                     builder.append("q").append(((ArgumentNode)preNode).getName());
  2682.                 }
  2683.             }
  2684.         }

  2686.         if (argsNode.getOptArgs() != null) {
  2687.             for (Node optNode : argsNode.getOptArgs().childNodes()) {
  2688.                 if (added) builder.append(';');
  2689.                 added = true;
  2690.                 builder.append("o");
  2691.                 if (optNode instanceof OptArgNode) {
  2692.                     builder.append(((OptArgNode)optNode).getName());
  2693.                 } else if (optNode instanceof LocalAsgnNode) {
  2694.                     builder.append(((LocalAsgnNode)optNode).getName());
  2695.                 } else if (optNode instanceof DAsgnNode) {
  2696.                     builder.append(((DAsgnNode)optNode).getName());
  2697.                 }
  2698.             }
  2699.         }

  2701.         if (argsNode.getRestArg() >= 0) {
  2702.             if (added) builder.append(';');
  2703.             added = true;
  2704.             if (argsNode.getRestArgNode() instanceof UnnamedRestArgNode) {
  2705.                 if (((UnnamedRestArgNode) argsNode.getRestArgNode()).isStar()) builder.append("R");
  2706.             } else {
  2707.                 builder.append("r").append(argsNode.getRestArgNode().getName());
  2708.             }
  2709.         }

  2711.         if (argsNode.getPost() != null) {
  2712.             for (Node postNode : argsNode.getPost().childNodes()) {
  2713.                 if (added) builder.append(';');
  2714.                 added = true;
  2715.                 if (postNode instanceof MultipleAsgn19Node) {
  2716.                     builder.append("nil");
  2717.                 } else {
  2718.                     builder.append("q").append(((ArgumentNode)postNode).getName());
  2719.                 }
  2720.             }
  2721.         }

  2723.         if (argsNode.getBlock() != null) {
  2724.             if (added) builder.append(';');
  2725.             added = true;
  2726.             builder.append("b").append(argsNode.getBlock().getName());
  2727.         }

  2729.         if (!added) {
  2730.           return "NONE";
  2731.         }

  2733.         return builder.toString();
  2734.     }

  2736.     public static String encodeParameterList(List<String[]> args) {
  2737.         if (args.size() == 0) return "NONE";

  2739.         StringBuilder builder = new StringBuilder();

  2741.         boolean added = false;
  2742.         for (String[] desc : args) {
  2743.             if (added) builder.append(';');
  2744.             builder.append(desc[0]).append(desc[1]);
  2745.             added = true;
  2746.         }

  2748.         return builder.toString();
  2749.     }

  2751.     public static RubyArray parameterListToParameters(Ruby runtime, String[] parameterList, boolean isLambda) {
  2752.         RubyArray parms = RubyArray.newEmptyArray(runtime);

  2754.         for (String param : parameterList) {
  2755.             if (param.equals("NONE")) break;

  2757.             RubyArray elem = RubyArray.newEmptyArray(runtime);
  2758.             if (param.equals("nil")) {
  2759.                 // marker for masgn args (the parens in "a, b, (c, d)"
  2760.                 elem.add(RubySymbol.newSymbol(runtime, isLambda ? "req" : "opt"));
  2761.                 parms.add(elem);
  2762.                 continue;
  2763.             }

  2765.             if (param.length() == 0) System.out.println(Arrays.toString(parameterList));
  2766.             if (param.charAt(0) == 'q') {
  2767.                 // required/normal arg
  2768.                 elem.add(RubySymbol.newSymbol(runtime, isLambda ? "req" : "opt"));
  2769.             } else if (param.charAt(0) == 'r') {
  2770.                 // named rest arg
  2771.                 elem.add(RubySymbol.newSymbol(runtime, "rest"));
  2772.             } else if (param.charAt(0) == 'R') {
  2773.                 // unnamed rest arg (star)
  2774.                 elem.add(RubySymbol.newSymbol(runtime, "rest"));
  2775.                 parms.add(elem);
  2776.                 continue;
  2777.             } else if (param.charAt(0) == 'o') {
  2778.                 // optional arg
  2779.                 elem.add(RubySymbol.newSymbol(runtime, "opt"));
  2780.                 if (param.length() == 1) {
  2781.                     // no name; continue
  2782.                     parms.add(elem);
  2783.                     continue;
  2784.                 }
  2785.             } else if (param.charAt(0) == 'b') {
  2786.                 // block arg
  2787.                 elem.add(RubySymbol.newSymbol(runtime, "block"));
  2788.             }

  2790.             if (param.length() > 1) {
  2791.                 elem.add(RubySymbol.newSymbol(runtime, param.substring(1)));
  2792.             }

  2794.             parms.add(elem);
  2795.         }

  2797.         return parms;
  2798.     }

  2800.     public static String[] irMethodArgsToParameters(List<String[]> argDesc) {
  2801.         String[] tmp = new String[argDesc.size()];
  2802.         for (int i = 0; i < tmp.length; i++) {
  2803.             String[] arg = argDesc.get(i);
  2804.             String encoded = arg[0].charAt(0) + arg[1];
  2805.             tmp[i] = encoded;
  2806.         }

  2808.         return tmp;
  2809.     }

  2811.     public static RubyString getDefinedCall(ThreadContext context, IRubyObject self, IRubyObject receiver, String name) {
  2812.         RubyClass metaClass = receiver.getMetaClass();
  2813.         DynamicMethod method = metaClass.searchMethod(name);
  2814.         Visibility visibility = method.getVisibility();

  2816.         if (visibility != Visibility.PRIVATE &&
  2817.                 (visibility != Visibility.PROTECTED || metaClass.getRealClass().isInstance(self)) && !method.isUndefined()) {
  2818.             return context.runtime.getDefinedMessage(DefinedMessage.METHOD);
  2819.         }

  2821.         if (receiver.callMethod(context, "respond_to_missing?",
  2822.             new IRubyObject[]{context.runtime.newSymbol(name), context.runtime.getFalse()}).isTrue()) {
  2823.             return context.runtime.getDefinedMessage(DefinedMessage.METHOD);
  2824.         }
  2825.         return null;
  2826.     }

  2828.     public static RubyString getDefinedNot(Ruby runtime, RubyString definition) {
  2829.         if (definition != null) {
  2830.             definition = runtime.getDefinedMessage(DefinedMessage.METHOD);
  2831.         }

  2833.         return definition;
  2834.     }

  2836.     public static IRubyObject invokedynamic(ThreadContext context, IRubyObject self, MethodNames method) {
  2837.         RubyClass metaclass = self.getMetaClass();
  2838.         String name = method.realName();
  2839.         return getMethodCached(context, metaclass, method.ordinal(), name).call(context, self, metaclass, name);
  2840.     }

  2842.     public static IRubyObject invokedynamic(ThreadContext context, IRubyObject self, MethodNames method, IRubyObject arg0) {
  2843.         RubyClass metaclass = self.getMetaClass();
  2844.         String name = method.realName();
  2845.         return getMethodCached(context, metaclass, method.ordinal(), name).call(context, self, metaclass, name, arg0);
  2846.     }
  2847.     
  2848.     private static DynamicMethod getMethodCached(ThreadContext context, RubyClass metaclass, int index, String name) {
  2849.         if (metaclass.getClassIndex() == ClassIndex.NO_INDEX) return metaclass.searchMethod(name);
  2850.         return context.runtimeCache.getMethod(context, metaclass, metaclass.getClassIndex().ordinal() * (index + 1), name);
  2851.     }
  2852.     
  2853.     public static IRubyObject lastElement(IRubyObject[] ary) {
  2854.         return ary[ary.length - 1];
  2855.     }
  2856.     
  2857.     public static RubyString appendAsString(RubyString target, IRubyObject other) {
  2858.         return target.append(other.asString());
  2859.     }
  2860.     
  2861.     public static RubyString appendAsString19(RubyString target, IRubyObject other) {
  2862.         return target.append19(other.asString());
  2863.     }

  2865.     /**
  2866.      * We need to splat incoming array to a block when |a, *b| (any required +
  2867.      * rest) or |a, b| (>1 required).
  2868.      */
  2869.     public static boolean needsSplat19(int requiredCount, boolean isRest) {
  2870.         return (isRest && requiredCount > 0) || (!isRest && requiredCount > 1);
  2871.     }

  2873.     // . Array given to rest should pass itself
  2874.     // . Array with rest + other args should extract array
  2875.     // . Array with multiple values and NO rest should extract args if there are more than one argument
  2876.     // Note: In 1.9 alreadyArray is only relevent from our internal Java code in core libs.  We never use it
  2877.     // from interpreter or JIT.  FIXME: Change core lib consumers to stop using alreadyArray param.
  2878.     public static IRubyObject[] restructureBlockArgs19(IRubyObject value, Arity arity, Block.Type type, boolean needsSplat, boolean alreadyArray) {
  2879.         if (!type.checkArity && arity == Arity.NO_ARGUMENTS) return IRubyObject.NULL_ARRAY;
  2880.         
  2881.         if (value != null && !(value instanceof RubyArray) && needsSplat) value = Helpers.aryToAry(value);

  2883.         IRubyObject[] parameters;
  2884.         if (value == null) {
  2885.             parameters = IRubyObject.NULL_ARRAY;
  2886.         } else if (value instanceof RubyArray && (alreadyArray || needsSplat)) {
  2887.             parameters = ((RubyArray) value).toJavaArray();
  2888.         } else {
  2889.             parameters = new IRubyObject[] { value };
  2890.         }

  2892.         return parameters;
  2893.     }

  2895.     public static boolean BEQ(ThreadContext context, IRubyObject value1, IRubyObject value2) {
  2896.         return value1.op_equal(context, value2).isTrue();
  2897.     }

  2899.     public static boolean BNE(ThreadContext context, IRubyObject value1, IRubyObject value2) {
  2900.         boolean eql = value2 == context.nil || value2 == UndefinedValue.UNDEFINED ?
  2901.                 value1 == value2 : value1.op_equal(context, value2).isTrue();

  2903.         return !eql;
  2904.     }

  2906.     public static RubyModule checkIsRubyModule(ThreadContext context, Object object) {
  2907.         if (!(object instanceof RubyModule)) {
  2908.             throw context.runtime.newTypeError("no outer class/module");
  2909.         }

  2911.         return (RubyModule)object;
  2912.     }

  2914.     public static RubyClass newClassForIR(ThreadContext context, String name, IRubyObject self, RubyModule classContainer, Object superClass, boolean meta) {
  2915.         if (meta) return classContainer.getMetaClass();

  2917.         RubyClass sc = null;

  2919.         if (superClass == UndefinedValue.UNDEFINED) {
  2920.             sc = null;
  2921.         } else if (superClass != null) {
  2922.             RubyClass.checkInheritable((IRubyObject)superClass);

  2924.             sc = (RubyClass) superClass;
  2925.         }


  2928.         return classContainer.defineOrGetClassUnder(name, sc);
  2929.     }

  2931.     public static RubyString appendByteList(RubyString target, ByteList source) {
  2932.         target.getByteList().append(source);
  2933.         return target;
  2934.     }

  2936.     public static RubyString appendByteList19(RubyString target, ByteList source, int codeRange) {
  2937.         target.cat19(source, codeRange);
  2938.         return target;
  2939.     }

  2941.     public static RubyString shortcutAppend18(RubyString string, IRubyObject object) {
  2942.         if (object instanceof RubyFixnum || object instanceof RubyFloat || object instanceof RubySymbol) {
  2943.             return string.append(object);
  2944.         } else {
  2945.             return string.append(object.asString());
  2946.         }
  2947.     }

  2949.     public static RubyString shortcutAppend(RubyString string, IRubyObject object) {
  2950.         if (object instanceof RubyFixnum || object instanceof RubyFloat || object instanceof RubySymbol) {
  2951.             return string.append19(object);
  2952.         } else {
  2953.             return string.append19(object.asString());
  2954.         }
  2955.     }

  2957.     public static void irCheckArgsArrayArity(ThreadContext context, RubyArray args, int required, int opt, int rest) {
  2958.         int numArgs = args.size();
  2959.         if ((numArgs < required) || ((rest == -1) && (numArgs > (required + opt)))) {
  2960.             Arity.raiseArgumentError(context.runtime, numArgs, required, required + opt);
  2961.         }
  2962.     }

  2964.     @Deprecated
  2965.     public static IRubyObject invokedynamic(ThreadContext context, IRubyObject self, int index) {
  2966.         return invokedynamic(context, self, MethodNames.values()[index]);
  2967.     }

  2969.     @Deprecated
  2970.     public static IRubyObject invokedynamic(ThreadContext context, IRubyObject self, int index, IRubyObject arg0) {
  2971.         return invokedynamic(context, self, MethodNames.values()[index], arg0);
  2972.     }
  2973.     
  2974.     public static void throwException(final Throwable e) {
  2975.         Helpers.<RuntimeException>throwsUnchecked(e);
  2976.     }
  2977.     
  2978.     private static <T extends Throwable> void throwsUnchecked(Throwable t) throws T {
  2979.         throw (T)t;
  2980.     }
  2981.     
  2982.     /**
  2983.      * Decode the given value to a Java string using the following rules:
  2984.      * 
  2985.      * * If the string is all US-ASCII characters, it will be decoded as US-ASCII.
  2986.      * * If the string is a unicode encoding, it will be decoded as such.
  2987.      * * If the string is any other encoding, it will be encoded as raw bytes
  2988.      *   using ISO-8859-1.
  2989.      * 
  2990.      * This allows non-unicode, non-US-ASCII encodings to be represented in the
  2991.      * symbol table as their raw versions, but properly decodes unicode-
  2992.      * encoded strings.
  2993.      * 
  2994.      * @param value the value to decode
  2995.      * @return the resulting symbol string
  2996.      */
  2997.     public static String symbolBytesToString(ByteList value) {
  2998.         Encoding encoding = value.getEncoding();
  2999.         if (encoding == USASCIIEncoding.INSTANCE || encoding == ASCIIEncoding.INSTANCE) {
  3000.             return value.toString(); // raw
  3001.         } else if (encoding instanceof UnicodeEncoding) {
  3002.             return new String(value.getUnsafeBytes(), value.getBegin(), value.getRealSize(), value.getEncoding().getCharset());
  3003.         } else {
  3004.             return value.toString(); // raw
  3005.         }
  3006.     }

  3008.     /**
  3009.      * Decode a given ByteList to a Java string.
  3010.      *
  3011.      * @param runtime the current runtime
  3012.      * @param value the bytelist
  3013.      * @return a Java String representation of the ByteList
  3014.      */
  3015.     public static String decodeByteList(Ruby runtime, ByteList value) {
  3016.         byte[] unsafeBytes = value.getUnsafeBytes();
  3017.         int begin = value.getBegin();
  3018.         int length = value.length();
  3019.         
  3020.         Encoding encoding = value.getEncoding();

  3022.         if (encoding == UTF8Encoding.INSTANCE) {
  3023.             return RubyEncoding.decodeUTF8(unsafeBytes, begin, length);
  3024.         }

  3026.         Charset charset = runtime.getEncodingService().charsetForEncoding(encoding);

  3028.         if (charset == null) {
  3029.             try {
  3030.                 return new String(unsafeBytes, begin, length, encoding.toString());
  3031.             } catch (UnsupportedEncodingException uee) {
  3032.                 return value.toString();
  3033.             }
  3034.         }

  3036.         return RubyEncoding.decode(unsafeBytes, begin, length, charset);
  3037.     }
  3038.     
  3039.     /**
  3040.      * Convert a ByteList into a Java String by using its Encoding's Charset. If
  3041.      * the Charset is not available, fall back on other logic.
  3042.      * 
  3043.      * @param byteList the bytelist to decode
  3044.      * @return the decoded string
  3045.      */
  3046.     public static String byteListToString(ByteList byteList) {
  3047.         if (byteList.getEncoding().getCharset() != null) {
  3048.             return new String(byteList.getUnsafeBytes(), byteList.getBegin(), byteList.getRealSize(), byteList.getEncoding().getCharset());
  3049.         }
  3050.         
  3051.         return byteList.toString();
  3052.     }

  3054.     public static IRubyObject rewriteStackTraceAndThrow(ThreadContext context, Throwable t) {
  3055.         Ruby runtime = context.runtime;

  3057.         StackTraceElement[] javaTrace = t.getStackTrace();
  3058.         BacktraceData backtraceData = runtime.getInstanceConfig().getTraceType().getIntegratedBacktrace(context, javaTrace);
  3059.         t.setStackTrace(RaiseException.javaTraceFromRubyTrace(backtraceData.getBacktrace(runtime)));
  3060.         throwException(t);

  3062.         // not reached
  3063.         return null;
  3064.     }

  3066.     public static String stringJoin(String delimiter, String[] strings) {
  3067.         if (strings.length == 0) return "";
  3068.         StringBuilder sb = new StringBuilder(strings[0]);
  3069.         for (int i = 1; i < strings.length; i++) {
  3070.             sb.append(delimiter)
  3071.                     .append(strings[i]);
  3072.         }
  3073.         return sb.toString();
  3074.     }

  3076.     public static <T> T[] arrayOf(T... values) {
  3077.         return values;
  3078.     }

  3080.     public static <T> T[] arrayOf(Class<T> t, int size, T fill) {
  3081.         T[] ary = (T[])Array.newInstance(t, size);
  3082.         Arrays.fill(ary, fill);
  3083.         return ary;
  3084.     }

  3086.     public static int memchr(boolean[] ary, int start, int len, boolean find) {
  3087.         for (int i = 0; i < len; i++) {
  3088.             if (ary[i + start] == find) return i + start;
  3089.         }
  3090.         return -1;
  3091.     }

  3093.     @Deprecated
  3094.     public static StaticScope decodeRootScope(ThreadContext context, String scopeString) {
  3095.         return decodeScope(context, null, scopeString);
  3096.     }

  3098.     @Deprecated
  3099.     public static StaticScope decodeLocalScope(ThreadContext context, String scopeString) {
  3100.         return decodeScope(context, context.getCurrentStaticScope(), scopeString);
  3101.     }

  3103.     @Deprecated
  3104.     public static StaticScope decodeLocalScope(ThreadContext context, StaticScope parent, String scopeString) {
  3105.         return decodeScope(context, parent, scopeString);
  3106.     }

  3108.     @Deprecated
  3109.     public static StaticScope decodeBlockScope(ThreadContext context, String scopeString) {
  3110.         return decodeScope(context, context.getCurrentStaticScope(), scopeString);
  3111.     }
  3112. }
Created with JaCoCo 0.7.3.201501050207