jruby · Mar 20, 2015 · Mar 20, 2015
Showing with 65 additions and 31 deletions.

+0 −2 spec/truffle/tags/core/string/reverse_tags.txt

+61 −29 truffle/src/main/java/org/jruby/truffle/nodes/core/StringNodes.java

+4 −0 truffle/src/main/ruby/core/rubinius/common/string.rb
diff --git a/spec/truffle/tags/core/string/reverse_tags.txt b/spec/truffle/tags/core/string/reverse_tags.txt
diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/core/StringNodes.java b/truffle/src/main/java/org/jruby/truffle/nodes/core/StringNodes.java
@@ -1340,7 +1340,9 @@ public Object initializeCopy(RubyString self, RubyString from) {
                 return self;
             }
 
-            self.getBytes().replace(from.getBytes().bytes());
+            self.getByteList().replace(from.getByteList().bytes());
+            self.getByteList().setEncoding(from.getByteList().getEncoding());
+            self.setCodeRange(from.getCodeRange());
 
             return self;
         }
@@ -1998,43 +2000,81 @@ public RubySymbol toSym(RubyString string) {
         }
     }
 
-    @CoreMethod(names = "reverse", taintFromSelf = true)
-    public abstract static class ReverseNode extends CoreMethodNode {
+    @CoreMethod(names = "reverse!", raiseIfFrozenSelf = true)
+    @ImportGuards(StringGuards.class)
+    public abstract static class ReverseBangNode extends CoreMethodNode {
 
-        public ReverseNode(RubyContext context, SourceSection sourceSection) {
+        public ReverseBangNode(RubyContext context, SourceSection sourceSection) {
             super(context, sourceSection);
         }
 
-        public ReverseNode(ReverseNode prev) {
+        public ReverseBangNode(ReverseBangNode prev) {
             super(prev);
         }
 
-        @Specialization
-        public RubyString reverse(RubyString string) {
-            notDesignedForCompilation();
-
-            return RubyString.fromByteList(string.getLogicalClass(), StringNodesHelper.reverse(string));
+        @Specialization(guards = "reverseIsEqualToSelf")
+        public RubyString reverseNoOp(RubyString string) {
+            return string;
         }
-    }
 
-    @CoreMethod(names = "reverse!", raiseIfFrozenSelf = true)
-    public abstract static class ReverseBangNode extends CoreMethodNode {
+        @Specialization(guards = { "!reverseIsEqualToSelf", "isSingleByteOptimizable" })
+        public RubyString reverseSingleByteOptimizable(RubyString string) {
+            // Taken from org.jruby.RubyString#reverse!
 
-        public ReverseBangNode(RubyContext context, SourceSection sourceSection) {
-            super(context, sourceSection);
-        }
+            string.modify();
 
-        public ReverseBangNode(ReverseBangNode prev) {
-            super(prev);
+            final byte[] bytes = string.getByteList().getUnsafeBytes();
+            final int p = string.getByteList().getBegin();
+            final int len = string.getByteList().getRealSize();
+
+            for (int i = 0; i < len >> 1; i++) {
+                byte b = bytes[p + i];
+                bytes[p + i] = bytes[p + len - i - 1];
+                bytes[p + len - i - 1] = b;
+            }
+
+            return string;
         }
 
-        @Specialization
+        @Specialization(guards = { "!reverseIsEqualToSelf", "!isSingleByteOptimizable" })
         public RubyString reverse(RubyString string) {
-            notDesignedForCompilation();
+            // Taken from org.jruby.RubyString#reverse!
+
+            string.modify();
+
+            final byte[] bytes = string.getByteList().getUnsafeBytes();
+            int p = string.getByteList().getBegin();
+            final int len = string.getByteList().getRealSize();
+
+            final Encoding enc = string.getByteList().getEncoding();
+            final int end = p + len;
+            int op = len;
+            final byte[] obytes = new byte[len];
+            boolean single = true;
+
+            while (p < end) {
+                int cl = StringSupport.length(enc, bytes, p, end);
+                if (cl > 1 || (bytes[p] & 0x80) != 0) {
+                    single = false;
+                    op -= cl;
+                    System.arraycopy(bytes, p, obytes, op, cl);
+                    p += cl;
+                } else {
+                    obytes[--op] = bytes[p++];
+                }
+            }
+
+            string.getByteList().setUnsafeBytes(obytes);
+            if (string.getCodeRange() == StringSupport.CR_UNKNOWN) {
+                string.setCodeRange(single ? StringSupport.CR_7BIT : StringSupport.CR_VALID);
+            }
 
-            string.set(StringNodesHelper.reverse(string));
             return string;
         }
+
+        public static boolean reverseIsEqualToSelf(RubyString string) {
+            return string.getByteList().getRealSize() <= 1;
+        }
     }
 
     @CoreMethod(names = "unpack", required = 1)
@@ -2265,14 +2305,6 @@ public static ByteList chompWithString(RubyString string, RubyString stringToCho
             return byteList;
         }
 
-        @TruffleBoundary
-        public static ByteList reverse(RubyString string) {
-            ByteList byteListString = ByteList.create(new StringBuilder(string.toString()).reverse().toString());
-            byteListString.setEncoding(string.getBytes().getEncoding());
-
-            return byteListString;
-        }
-
         @TruffleBoundary
         public static ByteList swapcase(RubyString string) {
             char[] charArray = string.toString().toCharArray();

diff --git a/truffle/src/main/ruby/core/rubinius/common/string.rb b/truffle/src/main/ruby/core/rubinius/common/string.rb
@@ -52,6 +52,10 @@ def hex
     to_inum(16, false)
   end
 
+  def reverse
+    dup.reverse!
+  end
+
   def split(pattern=nil, limit=undefined)
     Rubinius::Splitter.split(self, pattern, limit)
   end