jruby · Dec 23, 2016 · Dec 23, 2016 · Dec 23, 2016 · Dec 23, 2016 · Dec 23, 2016
diff --git a/truffle/src/main/java/org/jruby/truffle/core/array/ArrayUtils.java b/truffle/src/main/java/org/jruby/truffle/core/array/ArrayUtils.java
@@ -20,7 +20,22 @@ public abstract class ArrayUtils {
     public static final Object[] EMPTY_ARRAY = new Object[0];
 
     /**
-     * Extracts part of an array into a newly allocated Object[] array. Does not perform safety checks on parameters.
+     * Extracts part of an array into a newly allocated byte[] array. Does not perform safety checks on parameters.
+     * @param source the source array whose values should be extracted
+     * @param start the start index, must be >= 0 and <= source.length
+     * @param end the end index (exclusive), must be >= 0 and <= source.length and >= start
+     * @return a newly allocated array with the extracted elements and length (end - start)
+     */
+    public static byte[] extractRange(byte[] source, int start, int end) {
+        assert assertExtractRangeArgs(source, start, end);
+        int length = end - start;
+        byte[] result = new byte[length];
+        System.arraycopy(source, start, result, 0, length);
+        return result;
+    }
+
+    /**
+     * Extracts part of an array into a newly allocated int[] array. Does not perform safety checks on parameters.
      * @param source the source array whose values should be extracted
      * @param start the start index, must be >= 0 and <= source.length
      * @param end the end index (exclusive), must be >= 0 and <= source.length and >= start
@@ -35,7 +50,7 @@ public static int[] extractRange(int[] source, int start, int end) {
     }
 
     /**
-     * Extracts part of an array into a newly allocated Object[] array. Does not perform safety checks on parameters.
+     * Extracts part of an array into a newly allocated long[] array. Does not perform safety checks on parameters.
      * @param source the source array whose values should be extracted
      * @param start the start index, must be >= 0 and <= source.length
      * @param end the end index (exclusive), must be >= 0 and <= source.length and >= start
@@ -50,7 +65,7 @@ public static long[] extractRange(long[] source, int start, int end) {
     }
 
     /**
-     * Extracts part of an array into a newly allocated Object[] array. Does not perform safety checks on parameters.
+     * Extracts part of an array into a newly allocated double[] array. Does not perform safety checks on parameters.
      * @param source the source array whose values should be extracted
      * @param start the start index, must be >= 0 and <= source.length
      * @param end the end index (exclusive), must be >= 0 and <= source.length and >= start

diff --git a/truffle/src/main/java/org/jruby/truffle/core/rope/RopeOperations.java b/truffle/src/main/java/org/jruby/truffle/core/rope/RopeOperations.java
@@ -24,6 +24,7 @@
 import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
 import com.oracle.truffle.api.object.DynamicObject;
 import org.jcodings.Encoding;
+import org.jcodings.ascii.AsciiTables;
 import org.jcodings.specific.ASCIIEncoding;
 import org.jcodings.specific.USASCIIEncoding;
 import org.jcodings.specific.UTF8Encoding;
@@ -611,4 +612,27 @@ private static CodeRange commonCodeRange(CodeRange first, CodeRange second) {
         return CR_VALID;
     }
 
+    @TruffleBoundary
+    public static int caseInsensitiveCmp(Rope value, Rope other) {
+        // Taken from org.jruby.util.ByteList#caseInsensitiveCmp.
+
+        if (other == value) return 0;
+
+        final int size = value.byteLength();
+        final int len =  Math.min(size, other.byteLength());
+        final byte[] other_bytes = other.getBytes();
+
+        for (int offset = -1; ++offset < len;) {
+            int myCharIgnoreCase = AsciiTables.ToLowerCaseTable[value.getBytes()[offset] & 0xff] & 0xff;
+            int otherCharIgnoreCase = AsciiTables.ToLowerCaseTable[other_bytes[offset] & 0xff] & 0xff;
+            if (myCharIgnoreCase < otherCharIgnoreCase) {
+                return -1;
+            } else if (myCharIgnoreCase > otherCharIgnoreCase) {
+                return 1;
+            }
+        }
+
+        return size == other.byteLength() ? 0 : size == len ? -1 : 1;
+    }
+
 }
diff --git a/truffle/src/main/java/org/jruby/truffle/core/string/CoreStrings.java b/truffle/src/main/java/org/jruby/truffle/core/string/CoreStrings.java
@@ -26,6 +26,7 @@ public class CoreStrings {
     public final CoreString FALSE;
     public final CoreString GLOBAL_VARIABLE;
     public final CoreString INSTANCE_VARIABLE;
+    public final CoreString INVALID_VALUE_FOR_FLOAT;
     public final CoreString LINE;
     public final CoreString LOCAL_VARIABLE;
     public final CoreString METHOD;
@@ -58,6 +59,7 @@ public CoreStrings(RubyContext context) {
         FALSE = new CoreString(context, "false");
         GLOBAL_VARIABLE = new CoreString(context, "global-variable");
         INSTANCE_VARIABLE = new CoreString(context, "instance-variable");
+        INVALID_VALUE_FOR_FLOAT = new CoreString(context, "invalid value for Float()");
         LINE = new CoreString(context, "line");
         LOCAL_VARIABLE = new CoreString(context, "local-variable");
         METHOD = new CoreString(context, "method");

diff --git a/truffle/src/main/java/org/jruby/truffle/core/string/DoubleConverter.java b/truffle/src/main/java/org/jruby/truffle/core/string/DoubleConverter.java
@@ -27,6 +27,7 @@
  ***** END LICENSE BLOCK *****/
 package org.jruby.truffle.core.string;
 
+import org.jruby.truffle.core.rope.Rope;
 import org.jruby.truffle.core.string.ByteList;
 import org.jruby.truffle.parser.SafeDoubleParser;
 
@@ -57,16 +58,16 @@ public class DoubleConverter {
     public DoubleConverter() {
     }
 
-    public void init(ByteList list, boolean isStrict) {
-        bytes = list.getUnsafeBytes();
-        index = list.begin();
-        endIndex = index + list.length();
+    public void init(Rope rope, boolean isStrict) {
+        bytes = rope.getBytes();
+        index = 0;
+        endIndex = index + rope.byteLength();
         this.isStrict = isStrict;
         // +2 for added exponent: E...
         // The algorithm trades digits for inc/dec exponent.
         // Worse case is adding E-1 when no exponent,
         // it trades one digit for 3 chars.
-        chars = new char[Math.min(list.length() + 2, MAX_LENGTH)];
+        chars = new char[Math.min(rope.byteLength() + 2, MAX_LENGTH)];
         charsIndex = 0;
         significantDigitsProcessed = 0;
         adjustExponent = 0;
@@ -179,8 +180,8 @@ private boolean strictError() {
      * However, in order to maintain binary compatibility with extensions we can't
      * just change the signature either.
      */
-    public double parse(ByteList list, boolean strict, boolean is19) {
-        init(list, strict);
+    public double parse(Rope rope, boolean strict, boolean is19) {
+        init(rope, strict);
 
         if (skipWhitespace()) return completeCalculation();
         if (parseOptionalSign()) return completeCalculation();

diff --git a/truffle/src/main/java/org/jruby/truffle/core/string/StringCodeRangeableWrapper.java b/truffle/src/main/java/org/jruby/truffle/core/string/StringCodeRangeableWrapper.java