jruby · Nov 16, 2015 · Nov 16, 2015 · Nov 16, 2015 · Nov 16, 2015 · Nov 16, 2015
diff --git a/COPYING b/COPYING
@@ -78,6 +78,10 @@ below. Also see LICENSE.RUBY for most files found in lib/ruby/stdlib.
  Some parts of the RubySL implementations of the stdlib in lib/ruby/truffle/rubysl
  are copyright (c) 2013 Brian Shirai and are licensed under the 3-clause BSD license.
 
+ pr-zlib is copyright Park Heesob and Daniel Berger. "This library is covered
+ under the same license as zlib itself. For the text of the zlib license,
+ please see http://zlib.net/zlib_license.html."
+
 The complete text of the Eclipse Public License is as follows:
 
   Eclipse Public License - v 1.0

diff --git a/core/src/main/java/org/jruby/Main.java b/core/src/main/java/org/jruby/Main.java
@@ -38,6 +38,7 @@
 package org.jruby;
 
 import org.jruby.exceptions.MainExitException;
+import org.jruby.exceptions.JumpException;
 import org.jruby.exceptions.RaiseException;
 import org.jruby.exceptions.ThreadKill;
 import org.jruby.main.DripMain;
@@ -205,9 +206,14 @@ public static void main(String[] args) {
             if (status.isExit()) {
                 System.exit(status.getStatus());
             }
-        } catch (RaiseException rj) {
-            System.exit(handleRaiseException(rj));
-        } catch (Throwable t) {
+        }
+        catch (RaiseException ex) {
+            System.exit( handleRaiseException(ex) );
+        }
+        catch (JumpException ex) {
+            System.exit( handleUnexpectedJump(ex) );
+        }
+        catch (Throwable t) {
             // If a Truffle exception gets this far it's a hard failure - don't try and dress it up as a Ruby exception
 
             if (main.config.getCompileMode() == RubyInstanceConfig.CompileMode.TRUFFLE) {
@@ -516,25 +522,54 @@ private void doCheckSecurityManager() {
      * run should be System.err. In order to avoid the Ruby err being closed and unable
      * to write, we use System.err unconditionally.
      *
-     * @param rj
+     * @param ex
      * @return
      */
-    protected static int handleRaiseException(RaiseException rj) {
-        RubyException raisedException = rj.getException();
-        Ruby runtime = raisedException.getRuntime();
-        if (runtime.getSystemExit().isInstance(raisedException)) {
+    protected static int handleRaiseException(final RaiseException ex) {
+        RubyException raisedException = ex.getException();
+        final Ruby runtime = raisedException.getRuntime();
+        if ( runtime.getSystemExit().isInstance(raisedException) ) {
             IRubyObject status = raisedException.callMethod(runtime.getCurrentContext(), "status");
-            if (status != null && !status.isNil()) {
+            if (status != null && ! status.isNil()) {
                 return RubyNumeric.fix2int(status);
-            } else {
-                return 0;
             }
-        } else {
-            System.err.print(runtime.getInstanceConfig().getTraceType().printBacktrace(raisedException, runtime.getPosix().isatty(FileDescriptor.err)));
-            return 1;
+            return 0;
         }
+        System.err.print(runtime.getInstanceConfig().getTraceType().printBacktrace(raisedException, runtime.getPosix().isatty(FileDescriptor.err)));
+        return 1;
     }
 
+    private static int handleUnexpectedJump(final JumpException ex) {
+        if ( ex instanceof JumpException.SpecialJump ) { // ex == JumpException.SPECIAL_JUMP
+            System.err.println("Unexpected break: " + ex);
+        }
+        else if ( ex instanceof JumpException.FlowControlException ) {
+            // NOTE: assuming a single global runtime main(args) should have :
+            if ( Ruby.isGlobalRuntimeReady() ) {
+                final Ruby runtime = Ruby.getGlobalRuntime();
+                RaiseException raise = ((JumpException.FlowControlException) ex).buildException(runtime);
+                if ( raise != null ) handleRaiseException(raise);
+            }
+            else {
+                System.err.println("Unexpected jump: " + ex);
+            }
+        }
+        else {
+            System.err.println("Unexpected: " + ex);
+        }
+
+        final StackTraceElement[] trace = ex.getStackTrace();
+        if ( trace != null && trace.length > 0 ) {
+            System.err.println( ThreadContext.createRawBacktraceStringFromThrowable(ex, false) );
+        }
+        else {
+            System.err.println("HINT: to get backtrace for jump exceptions run with -Xjump.backtrace=true");
+        }
+
+        // TODO: should match MRI (>= 2.2.3) exit status - @see ruby/test_enum.rb#test_first
+        return 2;
+    }
+
     public static void printTruffleTimeMetric(String id) {
         if (Options.TRUFFLE_METRICS_TIME.load()) {
             final long millis = System.currentTimeMillis();

diff --git a/core/src/main/java/org/jruby/RubyArray.java b/core/src/main/java/org/jruby/RubyArray.java
@@ -2341,7 +2341,7 @@ public RubyArray collectBang(ThreadContext context, Block block) {
     */
     @JRubyMethod(name = "collect!")
     public IRubyObject collect_bang(ThreadContext context, Block block) {
-        return block.isGiven() ? collectBang(context, block) : enumeratorize(context.runtime, this, "collect!");
+        return block.isGiven() ? collectBang(context, block) : enumeratorizeWithSize(context, this, "collect!", enumLengthFn());
     }
 
     /** rb_ary_collect_bang

diff --git a/core/src/main/java/org/jruby/RubyClass.java b/core/src/main/java/org/jruby/RubyClass.java
@@ -1138,6 +1138,9 @@ public static void checkInheritable(IRubyObject superClass) {
         if (((RubyClass)superClass).isSingleton()) {
             throw superClass.getRuntime().newTypeError("can't make subclass of virtual class");
         }
+        if (superClass == superClass.getRuntime().getClassClass()) {
+            throw superClass.getRuntime().newTypeError("can't make subclass of Class");
+        }
     }
 
     public final ObjectMarshal getMarshal() {

diff --git a/core/src/main/java/org/jruby/RubyFloat.java b/core/src/main/java/org/jruby/RubyFloat.java
@@ -651,34 +651,38 @@ public IRubyObject op_le(ThreadContext context, double other) {
     @JRubyMethod(name = "eql?", required = 1)
     @Override
     public IRubyObject eql_p(IRubyObject other) {
-        if (other instanceof RubyFloat) {
-            double b = ((RubyFloat) other).value;
-            if (Double.isNaN(value) || Double.isNaN(b)) {
-                return getRuntime().getFalse();
-            }
-            if (value == b) {
-                return getRuntime().getTrue();
-            }
-        }
-        return getRuntime().getFalse();
+        return getRuntime().newBoolean( equals(other) );
     }
 
+    @Override
+    public boolean equals(Object other) {
+        return (other instanceof RubyFloat) && equals((RubyFloat) other);
+    }
+
+    private boolean equals(RubyFloat that) {
+        if ( Double.isNaN(this.value) || Double.isNaN(that.value) ) return false;
+        final double val1 = this.value == -0.0 ? 0.0 : this.value;
+        final double val2 = that.value == -0.0 ? 0.0 : that.value;
+        return Double.doubleToLongBits(val1) == Double.doubleToLongBits(val2);
+    }
+
     /** flo_hash
      * 
      */
     @JRubyMethod(name = "hash")
     @Override
     public RubyFixnum hash() {
-        return getRuntime().newFixnum(hashCode());
+        return getRuntime().newFixnum( hashCode() );
     }
 
     @Override
     public final int hashCode() {
-        long l = Double.doubleToLongBits(value);
-        return (int)(l ^ l >>> 32);
-    }    
+        final double val = value == 0.0 ? -0.0 : value;
+        final long l = Double.doubleToLongBits(val);
+        return (int) ( l ^ l >>> 32 );
+    }
 
-    /** flo_fo 
+    /** flo_fo
      * 
      */
     @JRubyMethod(name = "to_f")

diff --git a/core/src/main/java/org/jruby/RubyTime.java b/core/src/main/java/org/jruby/RubyTime.java
@@ -60,6 +60,7 @@
 
 import java.math.BigDecimal;
 import java.math.BigInteger;
+import java.math.RoundingMode;
 import java.util.Calendar;
 import java.util.Date;
 import java.util.GregorianCalendar;
@@ -81,9 +82,10 @@
 @JRubyClass(name="Time", include="Comparable")
 public class RubyTime extends RubyObject {
     public static final String UTC = "UTC";
-    public static final BigDecimal ONE_MILLION_BD = new BigDecimal(1000000);
+    @Deprecated // no longer used
+    public static final BigDecimal ONE_MILLION_BD = BigDecimal.valueOf(1000000);
     public static final BigInteger ONE_MILLION_BI = BigInteger.valueOf(1000000);
-    public static final BigDecimal ONE_THOUSAND_BD = new BigDecimal(1000);
+    public static final BigDecimal ONE_THOUSAND_BD = BigDecimal.valueOf(1000);
     private DateTime dt;
     private long nsec;
 
@@ -1058,12 +1060,19 @@ public static IRubyObject at(ThreadContext context, IRubyObject recv, IRubyObjec
                     long numerator = rational.numerator(context).convertToInteger().getLongValue();
                     long denominator = rational.denominator(context).convertToInteger().getLongValue();
 
-                    BigDecimal accurateSeconds = new BigDecimal(numerator).divide(new BigDecimal(denominator));
-                    BigDecimal accurateMillis = accurateSeconds.multiply(ONE_THOUSAND_BD);
-                    BigInteger integralMillis = accurateMillis.toBigInteger();
-                    BigInteger remainingNanos = accurateMillis.multiply(ONE_MILLION_BD).toBigInteger().subtract(integralMillis.multiply(ONE_MILLION_BI));
+                    final BigDecimal secs;
+                    if ( numerator <= Integer.MAX_VALUE ) {
+                        secs = new BigDecimal(numerator * 1000);
+                    }
+                    else {
+                        secs = BigDecimal.valueOf(numerator).multiply(ONE_THOUSAND_BD);
+                    }
+                    final BigDecimal millis = secs.divide(BigDecimal.valueOf(denominator), 12, RoundingMode.DOWN);
+
+                    final BigInteger roundMillis = millis.toBigInteger();
+                    BigInteger remainingNanos = millis.movePointRight(6).toBigInteger().subtract( roundMillis.multiply(ONE_MILLION_BI) );
 
-                    millisecs = integralMillis.longValue();
+                    millisecs = roundMillis.longValue();
                     nanosecs = remainingNanos.longValue();
                 }
             } else {

diff --git a/core/src/main/java/org/jruby/ext/bigdecimal/RubyBigDecimal.java b/core/src/main/java/org/jruby/ext/bigdecimal/RubyBigDecimal.java
@@ -506,24 +506,21 @@ private static RubyBigDecimal newInstance(ThreadContext context, IRubyObject rec
         String strValue = arg.convertToString().toString().trim();
 
         int sign = 1;
-        if(strValue.length() > 0) {
-            switch (strValue.charAt(0)) {
-                case '_' :
-                    return newZero(context.runtime, 1); // leading "_" are not allowed
-                case 'N' :
-                    if ( "NaN".equals(strValue) ) return newNaN(context.runtime);
-                    break;
-                case 'I' :
-                    if ( "Infinity".equals(strValue) ) return newInfinity(context.runtime, 1);
-                    break;
-                case '-' :
-                    if ( "-Infinity".equals(strValue) ) return newInfinity(context.runtime, -1);
-                    sign = -1;
-                    break;
-                case '+' :
-                    if ( "+Infinity".equals(strValue) ) return newInfinity(context.runtime, +1);
-                    break;
-            }
+        switch ( strValue.length() > 0 ? strValue.charAt(0) : ' ' ) {
+            case '_' : return newZero(context.runtime, 1); // leading "_" are not allowed
+            case 'N' :
+                if ( "NaN".equals(strValue) ) return newNaN(context.runtime);
+                break;
+            case 'I' :
+                if ( "Infinity".equals(strValue) ) return newInfinity(context.runtime, 1);
+                break;
+            case '-' :
+                if ( "-Infinity".equals(strValue) ) return newInfinity(context.runtime, -1);
+                sign = -1;
+                break;
+            case '+' :
+                if ( "+Infinity".equals(strValue) ) return newInfinity(context.runtime, +1);
+                break;
         }
 
         // Convert String to Java understandable format (for BigDecimal).
@@ -533,17 +530,21 @@ private static RubyBigDecimal newInstance(ThreadContext context, IRubyObject rec
         Matcher matcher = NUMBER_PATTERN.matcher(strValue);
         strValue = matcher.replaceFirst("$1");                          // 3. MRI ignores the trailing junk
 
-        String exp = matcher.group(2);
-        if(!exp.isEmpty()) {
+        String exp = matcher.group(2); int idx;
+        if ( exp != null && ! exp.isEmpty() ) {
             String expValue = matcher.group(3);
             if (expValue.isEmpty() || expValue.equals("-") || expValue.equals("+")) {
                 strValue = strValue.concat("0");                        // 4. MRI allows 1E, 1E-, 1E+
-            } else if (isExponentOutOfRange(expValue)) {
+            }
+            else if (isExponentOutOfRange(expValue)) {
                 // Handle infinity (Integer.MIN_VALUE + 1) < expValue < Integer.MAX_VALUE
                 return newInfinity(context.runtime, sign);
             }
         }
-
+        else if ( ( idx = matcher.start(3) ) > 0 ) {
+            strValue = strValue.substring(0, idx); // ignored tail junk e.g. "5-6" -> "-6"
+        }
+
         BigDecimal decimal;
         try {
             decimal = new BigDecimal(strValue, mathContext);

diff --git a/core/src/main/java/org/jruby/ext/timeout/Timeout.java b/core/src/main/java/org/jruby/ext/timeout/Timeout.java
@@ -46,7 +46,6 @@
 import org.jruby.anno.JRubyMethod;
 import org.jruby.exceptions.RaiseException;
 import org.jruby.runtime.Helpers;
-import org.jruby.runtime.Arity;
 import org.jruby.runtime.Block;
 import org.jruby.runtime.ThreadContext;
 import static org.jruby.runtime.Visibility.*;
@@ -58,9 +57,9 @@
 public class Timeout implements Library {
     public void load(Ruby runtime, boolean wrap) throws IOException {
         RubyModule timeout = runtime.defineModule("Timeout");
-        RubyClass superclass = runtime.getRuntimeError();
-        RubyClass timeoutError = runtime.defineClassUnder("Error", superclass, superclass.getAllocator(), timeout);
-        runtime.defineClassUnder("ExitException", runtime.getException(), runtime.getException().getAllocator(), timeout);
+        RubyClass RuntimeError = runtime.getRuntimeError();
+        RubyClass TimeoutError = runtime.defineClassUnder("Error", RuntimeError, RuntimeError.getAllocator(), timeout);
+        timeout.defineConstant("ExitException", TimeoutError);
 
         // Here we create an "anonymous" exception type used for unrolling the stack.
         // MRI creates a new one for *every call* to timeout, which can be costly.
@@ -76,7 +75,7 @@ public void load(Ruby runtime, boolean wrap) throws IOException {
         timeout.defineAnnotatedMethods(Timeout.class);
 
         // Toplevel defines
-        runtime.getObject().defineConstant("TimeoutError", timeoutError);
+        runtime.getObject().defineConstant("TimeoutError", TimeoutError);
         runtime.getObject().defineAnnotatedMethods(TimeoutToplevel.class);
     }
 

diff --git a/core/src/main/java/org/jruby/ir/IRClosure.java b/core/src/main/java/org/jruby/ir/IRClosure.java
@@ -16,6 +16,7 @@
 import org.jruby.runtime.BlockBody;
 import org.jruby.runtime.IRBlockBody;
 import org.jruby.runtime.MixedModeIRBlockBody;
+import org.jruby.runtime.InterpretedIRBlockBody;
 import org.jruby.runtime.Signature;
 import org.objectweb.asm.Handle;
 
@@ -67,7 +68,8 @@ protected IRClosure(IRClosure c, IRScope lexicalParent, int closureId, String fu
         if (getManager().isDryRun()) {
             this.body = null;
         } else {
-            this.body = new MixedModeIRBlockBody(c, c.getSignature());
+            boolean shouldJit = getManager().getInstanceConfig().getCompileMode().shouldJIT();
+            this.body = shouldJit ? new MixedModeIRBlockBody(c, c.getSignature()) : new InterpretedIRBlockBody(c, c.getSignature());
         }
 
         this.signature = c.signature;
@@ -90,7 +92,8 @@ public IRClosure(IRManager manager, IRScope lexicalParent, int lineNumber, Stati
         if (getManager().isDryRun()) {
             this.body = null;
         } else {
-            this.body = new MixedModeIRBlockBody(this, signature);
+            boolean shouldJit = manager.getInstanceConfig().getCompileMode().shouldJIT();
+            this.body = shouldJit ? new MixedModeIRBlockBody(this, signature) : new InterpretedIRBlockBody(this, signature);
             if (staticScope != null && !isBeginEndBlock) {
                 staticScope.setIRScope(this);
                 staticScope.setScopeType(this.getScopeType());

diff --git a/core/src/main/java/org/jruby/ir/IRVisitor.java b/core/src/main/java/org/jruby/ir/IRVisitor.java
@@ -88,6 +88,9 @@ private void error(Object object) {
     public void PopBindingInstr(PopBindingInstr popbindinginstr) { error(popbindinginstr); }
     public void PopBlockFrameInstr(PopBlockFrameInstr instr) { error(instr); }
     public void PopMethodFrameInstr(PopMethodFrameInstr instr) { error(instr); }
+    public void PrepareBlockArgsInstr(PrepareBlockArgsInstr instr) { error(instr); }
+    public void PrepareFixedBlockArgsInstr(PrepareFixedBlockArgsInstr instr) { error(instr); }
+    public void PrepareSingleBlockArgInstr(PrepareSingleBlockArgInstr instr) { error(instr); }
     public void ProcessModuleBodyInstr(ProcessModuleBodyInstr processmodulebodyinstr) { error(processmodulebodyinstr); }
     public void PutClassVariableInstr(PutClassVariableInstr putclassvariableinstr) { error(putclassvariableinstr); }
     public void PutConstInstr(PutConstInstr putconstinstr) { error(putconstinstr); }
@@ -112,8 +115,10 @@ private void error(Object object) {
     public void ReqdArgMultipleAsgnInstr(ReqdArgMultipleAsgnInstr reqdargmultipleasgninstr) { error(reqdargmultipleasgninstr); }
     public void RescueEQQInstr(RescueEQQInstr rescueeqqinstr) { error(rescueeqqinstr); }
     public void RestArgMultipleAsgnInstr(RestArgMultipleAsgnInstr restargmultipleasgninstr) { error(restargmultipleasgninstr); }
+    public void RestoreBindingVisibilityInstr(RestoreBindingVisibilityInstr instr) { error(instr); }
     public void ReturnInstr(ReturnInstr returninstr) { error(returninstr); }
     public void RuntimeHelperCall(RuntimeHelperCall runtimehelpercall) { error(runtimehelpercall); }
+    public void SaveBindingVisibilityInstr(SaveBindingVisibilityInstr instr) { error(instr); }
     public void SearchConstInstr(SearchConstInstr searchconstinstr) { error(searchconstinstr); }
     public void SetCapturedVarInstr(SetCapturedVarInstr instr) { error(instr); }
     public void StoreLocalVarInstr(StoreLocalVarInstr storelocalvarinstr) { error(storelocalvarinstr); }
@@ -123,6 +128,7 @@ private void error(Object object) {
     public void ToAryInstr(ToAryInstr toaryinstr) { error(toaryinstr); }
     public void UndefMethodInstr(UndefMethodInstr undefmethodinstr) { error(undefmethodinstr); }
     public void UnresolvedSuperInstr(UnresolvedSuperInstr unresolvedsuperinstr) { error(unresolvedsuperinstr); }
+    public void UpdateBlockExecutionStateInstr (UpdateBlockExecutionStateInstr instr) { error(instr); }
     public void YieldInstr(YieldInstr yieldinstr) { error(yieldinstr); }
     public void ZeroOperandArgNoBlockCallInstr(ZeroOperandArgNoBlockCallInstr zeroOperandArgNoBlockCallInstr) { error(zeroOperandArgNoBlockCallInstr); }
     public void ZSuperInstr(ZSuperInstr zsuperinstr) { error(zsuperinstr); }

diff --git a/core/src/main/java/org/jruby/ir/Operation.java b/core/src/main/java/org/jruby/ir/Operation.java
@@ -211,7 +211,14 @@ public enum Operation {
     PUSH_BLOCK_BINDING(OpFlags.f_is_book_keeping_op | OpFlags.f_has_side_effect),
     POP_BLOCK_FRAME(OpFlags.f_is_book_keeping_op | OpFlags.f_has_side_effect),
     POP_BINDING(OpFlags.f_is_book_keeping_op | OpFlags.f_has_side_effect),
-    TOGGLE_BACKTRACE(OpFlags.f_is_book_keeping_op | OpFlags.f_has_side_effect);
+    SAVE_BINDING_VIZ(OpFlags.f_is_book_keeping_op | OpFlags.f_has_side_effect),
+    RESTORE_BINDING_VIZ(OpFlags.f_is_book_keeping_op | OpFlags.f_has_side_effect),
+    TOGGLE_BACKTRACE(OpFlags.f_is_book_keeping_op | OpFlags.f_has_side_effect),
+    UPDATE_BLOCK_STATE(OpFlags.f_is_book_keeping_op | OpFlags.f_has_side_effect),
+
+    PREPARE_BLOCK_ARGS(OpFlags.f_is_book_keeping_op | OpFlags.f_has_side_effect),
+    PREPARE_SINGLE_BLOCK_ARG(OpFlags.f_is_book_keeping_op | OpFlags.f_has_side_effect),
+    PREPARE_FIXED_BLOCK_ARGS(OpFlags.f_is_book_keeping_op | OpFlags.f_has_side_effect);
 
     public final OpClass opClass;
     private int flags;